feat: expose js sdk identity without proxy wrappers

packages/angular/projects/angular-sdk/src/lib/feature-flag.directive.ts

@@ -132,7 +132,7 @@ export abstract class FeatureFlagDirective<T extends FlagValue> implements OnIni
     if (this._client) {
       this.disposeClient(this._client);
     }
-    this._client = OpenFeature.getClient(this._featureFlagDomain);
+    this._client = setAngularFrameworkMetadata(OpenFeature.getClient(this._featureFlagDomain));
 
     const baseHandler = () => {
       const result = this.getFlagDetails(this._featureFlagKey, this._featureFlagDefault);
@@ -230,6 +230,15 @@ export abstract class FeatureFlagDirective<T extends FlagValue> implements OnIni
   }
 }
 
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'angular') => Client;
+};
+
+function setAngularFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('angular');
+  return client;
+}
+
 /**
  * A structural directive that conditionally includes a template based on the evaluation
  * of a boolean feature flag.

packages/angular/projects/angular-sdk/src/lib/feature-flag.service.spec.ts

@@ -8,6 +8,7 @@ import { AsyncPipe } from '@angular/common';
 import { TestingProvider } from '../test/test.utils';
 import { OpenFeatureModule } from './open-feature.module';
 import { toSignal } from '@angular/core/rxjs-interop';
+import { vi } from 'vitest';
 
 const FLAG_KEY = 'thumbs';
 
@@ -114,6 +115,7 @@ describe('FeatureFlagService', () => {
 
   afterEach(async () => {
     await OpenFeature.close();
+    OpenFeature.clearHooks();
     await OpenFeature.setContext({});
     currentTestComponentFixture?.destroy();
     currentContextChangeDisabledComponentFixture?.destroy();
@@ -129,6 +131,27 @@ describe('FeatureFlagService', () => {
     expect(observableValue?.textContent).toBe('👍');
   });
 
+  it('should surface angular metadata in hook contexts', async () => {
+    const hook = { before: vi.fn() };
+
+    OpenFeature.addHooks(hook);
+    await createTestingModule();
+    service = TestBed.inject(FeatureFlagService);
+
+    await firstValueFrom(service.getBooleanDetails(FLAG_KEY, false));
+
+    expect(hook.before).toHaveBeenCalledWith(
+      expect.objectContaining({
+        clientMetadata: expect.objectContaining({
+          sdk: 'js-web',
+          paradigm: 'client',
+          framework: 'angular',
+        }),
+      }),
+      undefined,
+    );
+  });
+
   it('should render updated value after delay', async () => {
     const delay = 50;
     await createTestingModule({ providerInitDelay: delay });

packages/angular/projects/angular-sdk/src/lib/feature-flag.service.ts

@@ -217,7 +217,7 @@ export class FeatureFlagService {
     domain: string | undefined,
     options?: AngularFlagEvaluationOptions,
   ): Observable<EvaluationDetails<T>> {
-    const client = domain ? OpenFeature.getClient(domain) : OpenFeature.getClient();
+    const client = setAngularFrameworkMetadata(OpenFeature.getClient(domain));
 
     return new Observable<EvaluationDetails<T>>((subscriber) => {
       let currentResult: EvaluationDetails<T> | undefined = undefined;
@@ -266,3 +266,12 @@ export class FeatureFlagService {
     });
   }
 }
+
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'angular') => Client;
+};
+
+function setAngularFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('angular');
+  return client;
+}

packages/nest/src/open-feature.module.ts

@@ -22,6 +22,10 @@ import { APP_INTERCEPTOR } from '@nestjs/core';
 import { EvaluationContextInterceptor } from './evaluation-context-interceptor';
 import { ShutdownService } from './shutdown.service';
 
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'nest') => Client;
+};
+
 /**
  * OpenFeatureModule is a NestJS wrapper for OpenFeature Server-SDK.
  */
@@ -45,7 +49,7 @@ export class OpenFeatureModule {
     const clientValueProviders: NestFactoryProvider<Client>[] = [
       {
         provide: getOpenFeatureClientToken(),
-        useFactory: () => OpenFeature.getClient(),
+        useFactory: () => setNestFrameworkMetadata(OpenFeature.getClient()),
       },
     ];
 
@@ -58,7 +62,7 @@ export class OpenFeatureModule {
         OpenFeature.setProvider(domain, provider);
         clientValueProviders.push({
           provide: getOpenFeatureClientToken(domain),
-          useFactory: () => OpenFeature.getClient(domain),
+          useFactory: () => setNestFrameworkMetadata(OpenFeature.getClient(domain)),
         });
       });
     }
@@ -155,3 +159,8 @@ export interface OpenFeatureModuleOptions {
 export function getOpenFeatureClientToken(domain?: string): string {
   return domain ? `OpenFeatureClient_${domain}` : 'OpenFeatureClient_default';
 }
+
+function setNestFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('nest');
+  return client;
+}

packages/nest/src/utils.ts

@@ -1,12 +1,21 @@
 import type { Client, EvaluationContext } from '@openfeature/server-sdk';
 import { OpenFeature } from '@openfeature/server-sdk';
 
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'nest') => Client;
+};
+
 /**
  * Returns a domain scoped or the default OpenFeature client with the given context.
  * @param {string} domain The domain of the OpenFeature client.
  * @param {EvaluationContext} context The evaluation context of the client.
  * @returns {Client} The OpenFeature client.
  */
 export function getClientForEvaluation(domain?: string, context?: EvaluationContext) {
-  return domain ? OpenFeature.getClient(domain, context) : OpenFeature.getClient(context);
+  return setNestFrameworkMetadata(domain ? OpenFeature.getClient(domain, context) : OpenFeature.getClient(context));
+}
+
+function setNestFrameworkMetadata(client: Client): Client {
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('nest');
+  return client;
 }

packages/nest/test/open-feature.module.spec.ts

@@ -3,7 +3,7 @@ import { Test } from '@nestjs/testing';
 import { getOpenFeatureClientToken, OpenFeatureModule, ServerProviderEvents } from '../src';
 import type { Client } from '@openfeature/server-sdk';
 import { OpenFeature } from '@openfeature/server-sdk';
-import { getOpenFeatureDefaultTestModule } from './fixtures';
+import { defaultProvider, getOpenFeatureDefaultTestModule } from './fixtures';
 
 describe('OpenFeatureModule', () => {
   let moduleRef: TestingModule;
@@ -49,6 +49,48 @@ describe('OpenFeatureModule', () => {
       expect(client).toBeDefined();
       expect(await client.getStringValue('testStringFlag', '')).toEqual('expected-string-value-scoped');
     });
+
+    it('should expose nest framework metadata on injected clients', () => {
+      const defaultClient = moduleRef.get<Client>(getOpenFeatureClientToken());
+      const scopedClient = moduleRef.get<Client>(getOpenFeatureClientToken('domainScopedClient'));
+
+      expect(defaultClient.metadata).toMatchObject({
+        sdk: 'js-server',
+        paradigm: 'server',
+        framework: 'nest',
+      });
+      expect(scopedClient.metadata).toMatchObject({
+        sdk: 'js-server',
+        paradigm: 'server',
+        framework: 'nest',
+      });
+    });
+
+    it('should surface nest metadata in hook contexts', async () => {
+      const hook = { before: jest.fn() };
+      const hookModuleRef = await Test.createTestingModule({
+        imports: [OpenFeatureModule.forRoot({ defaultProvider, hooks: [hook] })],
+      }).compile();
+
+      try {
+        const client = hookModuleRef.get<Client>(getOpenFeatureClientToken());
+        await client.getBooleanValue('testBooleanFlag', false);
+
+        expect(hook.before).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientMetadata: expect.objectContaining({
+              sdk: 'js-server',
+              paradigm: 'server',
+              framework: 'nest',
+            }),
+          }),
+          undefined,
+        );
+      } finally {
+        await hookModuleRef.close();
+        OpenFeature.clearHooks();
+      }
+    });
   });
 
   describe('handlers', () => {

packages/react/src/provider/provider.tsx

@@ -4,6 +4,10 @@ import * as React from 'react';
 import type { ReactFlagEvaluationOptions } from '../options';
 import { Context } from '../internal';
 
+type FrameworkMetadataClient = Client & {
+  setFrameworkMetadata?: (framework: 'react') => Client;
+};
+
 type ClientOrDomain =
   | {
       /**
@@ -32,7 +36,22 @@ type ProviderProps = {
  * @returns {OpenFeatureProvider} context provider
  */
 export function OpenFeatureProvider({ client, domain, children, ...options }: ProviderProps) {
-  const stableClient = React.useMemo(() => client || OpenFeature.getClient(domain), [client, domain]);
+  const stableClient = React.useMemo(() => {
+    if (client) {
+      return setReactFrameworkMetadata(client);
+    }
+
+    return setReactFrameworkMetadata(OpenFeature.getClient(domain));
+  }, [client, domain]);
 
   return <Context.Provider value={{ client: stableClient, options }}>{children}</Context.Provider>;
 }
+
+function setReactFrameworkMetadata(client: Client): Client {
+  // When a caller provides an existing client, preserve that instance but mark it
+  // as React-backed so metadata stays aligned with provider-created clients.
+  // The cast is needed because `setFrameworkMetadata` is an internal method on the
+  // SDK-owned client implementation, not part of the public `Client` interface.
+  (client as FrameworkMetadataClient).setFrameworkMetadata?.('react');
+  return client;
+}

packages/react/test/provider.spec.tsx

@@ -53,13 +53,14 @@ describe('OpenFeatureProvider', () => {
 
   beforeEach(async () => {
     await OpenFeature.clearContexts();
+    OpenFeature.clearHooks();
   });
 
   describe('useOpenFeatureClient', () => {
     const DOMAIN = 'useOpenFeatureClient';
 
     describe('client specified', () => {
-      it('should return client from provider', () => {
+      it('should return client from provider with react metadata', () => {
         const client = OpenFeature.getClient(DOMAIN);
 
         const wrapper = ({ children }: Parameters<typeof OpenFeatureProvider>[0]) => (
@@ -69,6 +70,12 @@ describe('OpenFeatureProvider', () => {
         const { result } = renderHook(() => useOpenFeatureClient(), { wrapper });
 
         expect(result.current).toEqual(client);
+        expect(result.current.metadata).toMatchObject({
+          domain: DOMAIN,
+          sdk: 'js-web',
+          paradigm: 'client',
+          framework: 'react',
+        });
       });
     });
 
@@ -81,6 +88,9 @@ describe('OpenFeatureProvider', () => {
         const { result } = renderHook(() => useOpenFeatureClient(), { wrapper });
 
         expect(result.current.metadata.domain).toEqual(DOMAIN);
+        expect(result.current.metadata.sdk).toEqual('js-web');
+        expect(result.current.metadata.paradigm).toEqual('client');
+        expect(result.current.metadata.framework).toEqual('react');
       });
 
       it('should return a stable client across renders', () => {
@@ -96,6 +106,46 @@ describe('OpenFeatureProvider', () => {
 
         expect(firstClient).toBe(secondClient);
       });
+
+      it('should surface react metadata in hook contexts', async () => {
+        const hook = { before: jest.fn() };
+
+        OpenFeature.setProvider(
+          DOMAIN,
+          new InMemoryProvider({
+            greeting: {
+              disabled: false,
+              variants: { default: 'hello' },
+              defaultVariant: 'default',
+            },
+          }),
+        );
+
+        const wrapper = ({ children }: Parameters<typeof OpenFeatureProvider>[0]) => (
+          <OpenFeatureProvider domain={DOMAIN}>{children}</OpenFeatureProvider>
+        );
+
+        const { result } = renderHook(
+          () =>
+            useStringFlagValue('greeting', 'fallback', {
+              hooks: [hook],
+            }),
+          { wrapper },
+        );
+
+        await waitFor(() => expect(result.current).toEqual('hello'));
+        expect(hook.before).toHaveBeenCalledWith(
+          expect.objectContaining({
+            clientMetadata: expect.objectContaining({
+              domain: DOMAIN,
+              sdk: 'js-web',
+              paradigm: 'client',
+              framework: 'react',
+            }),
+          }),
+          undefined,
+        );
+      });
     });
   });
 

packages/server/src/client/client.ts

@@ -1,4 +1,4 @@
-import type { ClientMetadata, EvaluationLifeCycle, Eventing, ManageContext, ManageLogger } from '@openfeature/core';
+import type { EvaluationLifeCycle, Eventing, ManageContext, ManageLogger, MetadataClient } from '@openfeature/core';
 import type { Features } from '../evaluation';
 import type { ProviderStatus } from '../provider';
 import type { ProviderEvents } from '../events';
@@ -11,8 +11,8 @@ export interface Client
     ManageContext<Client>,
     ManageLogger<Client>,
     Tracking,
-    Eventing<ProviderEvents> {
-  readonly metadata: ClientMetadata;
+    Eventing<ProviderEvents>,
+    MetadataClient {
   /**
    * Returns the status of the associated provider.
    */

packages/server/src/client/internal/open-feature-client.ts

@@ -1,4 +1,5 @@
 import type {
+  ClientFramework,
   ClientMetadata,
   EvaluationContext,
   EvaluationDetails,
@@ -50,6 +51,7 @@ export class OpenFeatureClient implements Client {
   private _context: EvaluationContext;
   private _hooks: Hook[] = [];
   private _clientLogger?: Logger;
+  private _framework?: ClientFramework;
 
   constructor(
     // we always want the client to use the current provider,
@@ -73,10 +75,27 @@ export class OpenFeatureClient implements Client {
       name: this.options.domain ?? this.options.name,
       domain: this.options.domain ?? this.options.name,
       version: this.options.version,
+      sdk: 'js-server',
+      paradigm: 'server',
+      framework: this._framework,
       providerMetadata: this.providerAccessor().metadata,
     };
   }
 
+  /**
+   * Sets framework metadata on an existing SDK-owned client instance.
+   *
+   * This is used by framework wrappers that must preserve a pre-created client
+   * instance instead of constructing a new framework-aware client.
+   * @param {ClientFramework} framework framework metadata to expose
+   * @returns {this} the updated client
+   * @internal
+   */
+  setFrameworkMetadata(framework: ClientFramework): this {
+    this._framework = framework;
+    return this;
+  }
+
   get providerStatus(): ProviderStatus {
     return this.providerStatusAccessor();
   }