@oxyhq/core 20.1.0 → 21.0.1

package/src/mixins/__tests__/accounts.test.ts

@@ -17,9 +17,6 @@ import type { User } from '../../models/interfaces';
 import type {
   AccountNode,
   AccountMember,
-  AccountCredential,
-  AccountCredentialWithSecret,
-  RotateAccountCredentialResult,
   Application,
   ApplicationCredential,
   ApplicationCredentialWithSecret,
@@ -62,20 +59,6 @@ const accountNodeFixture: AccountNode = {
   childCount: 2,
 };
 
-const credentialFixture: AccountCredential = {
-  _id: 'cred1',
-  accountId: 'acc1',
-  name: 'bot-prod',
-  publicKey: 'oxy_dk_abc',
-  type: 'service',
-  environment: 'production',
-  scopes: ['user:read'],
-  status: 'active',
-  createdByUserId: 'u1',
-  createdAt: '2026-06-29T00:00:00.000Z',
-  updatedAt: '2026-06-29T00:00:00.000Z',
-};
-
 const appFixture: Application = {
   _id: 'app1',
   name: 'Mention',
@@ -476,91 +459,6 @@ describe('OxyServices.accounts', () => {
     });
   });
 
-  describe('listAccountCredentials', () => {
-    it('unwraps the `credentials` array and caches the read', async () => {
-      makeRequestSpy.mockResolvedValue({ credentials: [credentialFixture] });
-
-      const result = await oxy.listAccountCredentials('acc1');
-
-      expect(result).toEqual([credentialFixture]);
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'GET',
-        '/accounts/acc1/credentials',
-        undefined,
-        expect.objectContaining({ cache: true }),
-      );
-    });
-
-    it('returns an empty array when `credentials` is absent', async () => {
-      makeRequestSpy.mockResolvedValue({});
-      expect(await oxy.listAccountCredentials('acc1')).toEqual([]);
-    });
-  });
-
-  describe('createAccountCredential', () => {
-    it('posts the config, returns the secret result, and busts the credentials cache', async () => {
-      const created: AccountCredentialWithSecret = {
-        credential: credentialFixture,
-        secret: 'sk_once',
-      };
-      makeRequestSpy.mockResolvedValue(created);
-
-      const result = await oxy.createAccountCredential('acc1', {
-        name: 'bot-prod',
-        environment: 'production',
-      });
-
-      expect(result).toEqual(created);
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'POST',
-        '/accounts/acc1/credentials',
-        { name: 'bot-prod', environment: 'production' },
-        expect.objectContaining({ cache: false }),
-      );
-      expect(clearEntrySpy).toHaveBeenCalledWith('GET:/accounts/acc1/credentials');
-    });
-  });
-
-  describe('rotateAccountCredential', () => {
-    it('posts to /rotate, encodes ids, returns the audit result, and busts credentials', async () => {
-      const rotated: RotateAccountCredentialResult = {
-        credential: { ...credentialFixture, _id: 'cred2' },
-        secret: 'sk_new',
-        rotatedFrom: 'cred1',
-        graceExpiresAt: '2026-07-06T00:00:00.000Z',
-      };
-      makeRequestSpy.mockResolvedValue(rotated);
-
-      const result = await oxy.rotateAccountCredential('acc1', 'cred 1');
-
-      expect(result).toEqual(rotated);
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'POST',
-        '/accounts/acc1/credentials/cred%201/rotate',
-        undefined,
-        expect.objectContaining({ cache: false }),
-      );
-      expect(clearEntrySpy).toHaveBeenCalledWith('GET:/accounts/acc1/credentials');
-    });
-  });
-
-  describe('revokeAccountCredential', () => {
-    it('deletes the credential and busts the credentials cache', async () => {
-      makeRequestSpy.mockResolvedValue({ success: true });
-
-      const result = await oxy.revokeAccountCredential('acc1', 'cred1');
-
-      expect(result).toEqual({ success: true });
-      expect(makeRequestSpy).toHaveBeenCalledWith(
-        'DELETE',
-        '/accounts/acc1/credentials/cred1',
-        undefined,
-        expect.objectContaining({ cache: false }),
-      );
-      expect(clearEntrySpy).toHaveBeenCalledWith('GET:/accounts/acc1/credentials');
-    });
-  });
-
   describe('createApp', () => {
     it('posts the payload, unwraps `application`, and busts every app list', async () => {
       makeRequestSpy.mockResolvedValue({ application: appFixture });
@@ -678,6 +576,39 @@ describe('OxyServices.accounts', () => {
       );
       expect(clearEntrySpy).toHaveBeenCalledWith('GET:/applications/app1/credentials');
     });
+
+    it("forwards a machine credential's expiresInSeconds and its one-time token", async () => {
+      // A `machine` credential's material arrives in `token`, never `secret` —
+      // a surface rendering "the secret" must not silently print an API key.
+      const created: ApplicationCredentialWithSecret = {
+        credential: { ...appCredentialFixture, type: 'machine', tokenPrefix: 'oxy_sk_0123456789abcdef' },
+        secret: null,
+        token: 'oxy_sk_0123456789abcdef_' + 'a'.repeat(64),
+      };
+      makeRequestSpy.mockResolvedValue(created);
+
+      const result = await oxy.createAppCredential('app1', {
+        name: 'ci-runner',
+        type: 'machine',
+        environment: 'production',
+        scopes: ['inference:invoke'],
+        expiresInSeconds: 86_400,
+      });
+
+      expect(result.token).toBe(created.token);
+      expect(makeRequestSpy).toHaveBeenCalledWith(
+        'POST',
+        '/applications/app1/credentials',
+        {
+          name: 'ci-runner',
+          type: 'machine',
+          environment: 'production',
+          scopes: ['inference:invoke'],
+          expiresInSeconds: 86_400,
+        },
+        expect.objectContaining({ cache: false }),
+      );
+    });
   });
 
   describe('rotateAppCredential', () => {
@@ -701,6 +632,30 @@ describe('OxyServices.accounts', () => {
       );
       expect(clearEntrySpy).toHaveBeenCalledWith('GET:/applications/app1/credentials');
     });
+
+    it('forwards an opt-in rotation grace window', async () => {
+      // Omitting it (the case above) sends `undefined`, and the server then
+      // revokes the superseded machine token immediately. Sending it must reach
+      // the body, or a caller asking for zero-downtime rotation would silently
+      // get the instant-revoke behaviour instead.
+      const rotated: RotateApplicationCredentialResult = {
+        credential: { ...appCredentialFixture, _id: 'appcred2', type: 'machine' },
+        secret: null,
+        token: 'oxy_sk_fedcba9876543210_' + 'b'.repeat(64),
+        rotatedFrom: 'appcred1',
+        graceExpiresAt: '2026-08-17T00:00:00.000Z',
+      };
+      makeRequestSpy.mockResolvedValue(rotated);
+
+      await oxy.rotateAppCredential('app1', 'appcred1', { graceSeconds: 3600 });
+
+      expect(makeRequestSpy).toHaveBeenCalledWith(
+        'POST',
+        '/applications/app1/credentials/appcred1/rotate',
+        { graceSeconds: 3600 },
+        expect.objectContaining({ cache: false }),
+      );
+    });
   });
 
   describe('revokeAppCredential', () => {

package/src/mixins/__tests__/inferenceFactory.test.ts

@@ -0,0 +1,58 @@
+/**
+ * `oxyServices.inference()` — the binding, which is the only thing this mixin
+ * does.
+ *
+ * Two properties matter and neither is visible from the client's own suite: the
+ * client must inherit THIS instance's base URL, and it must read the bearer
+ * LATE, so a token planted after construction is the one that gets sent. A
+ * factory that captured `getAccessToken()` eagerly would pass every test that
+ * signs in first and fail on the cold-boot ordering every app actually has.
+ *
+ * Driven through the real global `fetch`, spied — the factory takes no
+ * transport, so a test that built its own client would be asserting against a
+ * re-implementation of the thing under test rather than against it.
+ */
+
+import { OxyServices } from '../../OxyServices';
+import { OxyInferenceClient } from '../../inference/OxyInferenceClient';
+
+describe('OxyServices.inference()', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        fetchSpy = jest.spyOn(globalThis, 'fetch').mockResolvedValue(
+            new Response(JSON.stringify({ data: [], count: 0 }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            }),
+        );
+    });
+
+    afterEach(() => {
+        fetchSpy.mockRestore();
+    });
+
+    it('returns one memoized client, so a consumer can hold it', () => {
+        const oxy = new OxyServices({ baseURL: 'http://test.invalid' });
+
+        const first = oxy.inference();
+        expect(first).toBeInstanceOf(OxyInferenceClient);
+        expect(oxy.inference()).toBe(first);
+    });
+
+    it('binds this instance base URL and reads the bearer at request time', async () => {
+        const oxy = new OxyServices({ baseURL: 'http://test.invalid' });
+        const client = oxy.inference();
+
+        // The token is planted AFTER the client exists — the cold-boot order.
+        oxy.setTokens('planted-later');
+        await client.listModels();
+
+        expect(fetchSpy).toHaveBeenCalledTimes(1);
+        const [url, init] = fetchSpy.mock.calls[0] as [string, RequestInit];
+        expect(String(url)).toBe('http://test.invalid/v1/models');
+        expect((init.headers as Record<string, string>)['Authorization']).toBe(
+            'Bearer planted-later',
+        );
+    });
+});

package/src/mixins/__tests__/preSessionSkipAuth.test.ts

@@ -158,7 +158,40 @@ describe('pre-session public endpoints use skipAuth', () => {
     });
   });
 
-  it('exchangeOAuthCode rejects a response without deviceSecret', async () => {
+  // A third-party grant is meant to be ISOLATED from the browser's shared
+  // DeviceSession, so the token endpoint must be free to return no device
+  // credential. Core used to require the pair, which made that omission
+  // unshippable: every third-party sign-in through the SDK would have collapsed
+  // into a silent `exchange-failed` (issue #954).
+  it('exchangeOAuthCode accepts a device-less grant and still plants the token', async () => {
+    makeRequest.mockResolvedValueOnce({
+      access_token: 'tok',
+      token_type: 'Bearer',
+      expires_in: 900,
+      session_id: 's1',
+      user: { id: 'u1', username: 'alice' },
+    });
+
+    const result = await oxy.exchangeOAuthCode({
+      code: 'code-1',
+      clientId: 'oxy_dk_test',
+      redirectUri: 'https://app.example/callback',
+      codeVerifier: 'verifier',
+    });
+
+    expect(result).toMatchObject({
+      sessionId: 's1',
+      accessToken: 'tok',
+      user: { id: 'u1', username: 'alice' },
+    });
+    // Absent, not `undefined`-valued: a device-less grant carries no device keys
+    // at all, so nothing downstream can read one and persist an empty credential.
+    expect(result).not.toHaveProperty('deviceId');
+    expect(result).not.toHaveProperty('deviceSecret');
+    expect(oxy.getAccessToken()).toBe('tok');
+  });
+
+  it('exchangeOAuthCode accepts a deviceId with no deviceSecret', async () => {
     makeRequest.mockResolvedValueOnce({
       access_token: 'tok',
       token_type: 'Bearer',
@@ -167,6 +200,26 @@ describe('pre-session public endpoints use skipAuth', () => {
       deviceId: 'd1',
       user: { id: 'u1' },
     });
+
+    const result = await oxy.exchangeOAuthCode({
+      code: 'code-1',
+      clientId: 'oxy_dk_test',
+      redirectUri: 'https://app.example/callback',
+      codeVerifier: 'verifier',
+    });
+
+    expect(result).toMatchObject({ sessionId: 's1', deviceId: 'd1' });
+    expect(result).not.toHaveProperty('deviceSecret');
+  });
+
+  // The device pair left the guard; what identifies the session did NOT. Without
+  // these two the whole guard could be deleted and every test above would stay
+  // green — `sessionId` would silently become `undefined` on the returned session.
+  it.each([
+    ['session_id', { access_token: 'tok', expires_in: 900, user: { id: 'u1' } }],
+    ['user', { access_token: 'tok', expires_in: 900, session_id: 's1' }],
+  ])('exchangeOAuthCode still rejects a response missing %s', async (_field, response) => {
+    makeRequest.mockResolvedValueOnce(response);
     await expect(
       oxy.exchangeOAuthCode({
         code: 'code-1',

package/src/mixins/__tests__/serviceAuth.test.ts

@@ -50,6 +50,7 @@ const signServiceToken = (claims: ServiceTokenClaims, secret: string): string =>
     aud: 'oxy-api',
     iss: 'oxy-auth',
     credentialId: 'cred-1',
+    ownerAccountId: 'owner-account-1',
     environment: 'production',
     ...claims,
   };
@@ -184,6 +185,7 @@ describe('C3: service-token acting-as enforcement', () => {
       appId: 'app-1',
       appName: 'trusted-service',
       credentialId: 'cred-1',
+      ownerAccountId: 'owner-account-1',
       scopes: ['user:read'],
       environment: 'production',
     });

package/src/mixins/index.ts

@@ -33,6 +33,7 @@ import { OxyServicesChainsMixin } from './OxyServices.chains';
 import { OxyServicesNodesMixin } from './OxyServices.nodes';
 import { OxyServicesLinksMixin } from './OxyServices.links';
 import { OxyServicesFollowGraphMixin } from './OxyServices.followGraph';
+import { OxyServicesInferenceMixin } from './OxyServices.inference';
 import { OxyServicesDeviceBootMixin } from './OxyServices.deviceBoot';
 import { OxyServicesDeviceTransferMixin } from './OxyServices.deviceTransfer';
 
@@ -72,6 +73,7 @@ type AllMixinInstances =
   & InstanceType<ReturnType<typeof OxyServicesNodesMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesLinksMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesFollowGraphMixin<typeof OxyServicesBase>>>
+  & InstanceType<ReturnType<typeof OxyServicesInferenceMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesDeviceBootMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesDeviceTransferMixin<typeof OxyServicesBase>>>
   & InstanceType<ReturnType<typeof OxyServicesUtilityMixin<typeof OxyServicesBase>>>;
@@ -156,6 +158,12 @@ const MIXIN_PIPELINE: MixinFunction[] = [
     // shared across applications, with per-application context on top.
     OxyServicesFollowGraphMixin,
 
+    // The inference model catalogue (#972). Reads only, and deliberately no
+    // request/stream/receipt methods — the public inference edge those would
+    // call is workstream 4 and does not exist yet. See
+    // `docs/inference/README.md` for what is and is not built.
+    OxyServicesInferenceMixin,
+
     // Device-first token mint: the client half of the zero-cookie transport
     // (`mintFromDeviceSecret` → `POST /session/device/token`).
     OxyServicesDeviceBootMixin,

package/src/models/session.ts

@@ -14,6 +14,17 @@ export interface ClientSession {
    * account-chooser ordering, not for any token-refresh mechanism.
    */
   authuser?: number;
+  /**
+   * The HUMAN operating this account, when it is a delegated session — the
+   * audit actor behind "The Oxy Collective". Absent when the session belongs to
+   * the account itself.
+   *
+   * The flat wire shape has carried it since the multi-account model shipped and
+   * nothing read it, so an operated org rendered exactly like a directly
+   * signed-in one. `SessionClient.getActiveContext()` is the richer answer
+   * (ADR 0002); this is the same fact on the compatibility lane.
+   */
+  operatedByUserId?: string;
 }
 
 export interface StorageKeys {