@openchambery/web 1.19.22-beta.1 → 2.0.0-beta.10

package/server/lib/conversations/service.js

@@ -1,15 +1,66 @@
-import { createOpencodeClient } from '@opencode-ai/sdk/v2';
+import { OpenCode } from '@opencode/client';
 
 // --- error classification ---
 
 const isTransportError = (error) => {
   if (!error) return true;
+  if (error.reason === 'Transport') return true;
   if (error.name === 'TypeError' || error.name === 'FetchError' || error.name === 'AbortError') return true;
+  if (error.cause?.name === 'TypeError' || error.cause?.name === 'FetchError' || error.cause?.name === 'AbortError') return true;
   const code = error.cause?.code || error.code;
   if (code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'ECONNRESET' || code === 'ETIMEDOUT' || code === 'EPIPE') return true;
   return false;
 };
 
+// v2 client throws raw data or ClientError; recover HTTP status when present.
+const getHttpStatus = (error) => {
+  const candidates = [error?.cause?.status, error?.status, error?.response?.status];
+  for (const value of candidates) {
+    if (Number.isFinite(value)) return value;
+  }
+  return undefined;
+};
+
+const classifyPromptFailure = (error) => {
+  if (isTransportError(error)) {
+    return { ambiguous: true, status: undefined };
+  }
+  const status = getHttpStatus(error);
+  if (Number.isFinite(status)) {
+    return { ambiguous: isRetryableHttpStatus(status), status };
+  }
+  // Declared v2 HTTP errors (400/401/404/409) throw JSON without a status field.
+  return { ambiguous: false, status: 400 };
+};
+
+// Map sanitized parts onto the official v2 prompt body (text/files/agents).
+const toV2PromptInput = (sanitizedInput, sessionID) => {
+  const text = sanitizedInput.parts
+    .filter((part) => part.type === 'text')
+    .map((part) => part.text)
+    .join('\n');
+  const files = sanitizedInput.parts
+    .filter((part) => part.type === 'file')
+    .map((part) => ({
+      uri: part.url,
+      ...(part.filename ? { name: part.filename } : {}),
+    }));
+  const agents = sanitizedInput.parts
+    .filter((part) => part.type === 'agent')
+    .map((part) => ({ name: part.name }));
+
+  return {
+    sessionID,
+    id: sanitizedInput.messageID,
+    text,
+    ...(files.length > 0 ? { files } : {}),
+    ...(agents.length > 0 ? { agents } : {}),
+    ...(sanitizedInput.skills?.length ? { skills: sanitizedInput.skills.map(({ id }) => ({ id, name: id })) } : {}),
+    ...(sanitizedInput.metadata ? { metadata: sanitizedInput.metadata } : {}),
+    delivery: 'steer',
+  };
+};
+
 const isRetryableHttpStatus = (status) => {
   if (!Number.isFinite(status)) return true;
   return status === 408 || status === 429 || status >= 500;
@@ -84,7 +135,7 @@ export const createConversationsService = (deps) => {
 
     const baseUrl = buildOpenCodeUrl('/', '').replace(/\/$/, '');
     const authHeaders = getOpenCodeAuthHeaders();
-    return createOpencodeClient({ baseUrl, headers: authHeaders });
+    return OpenCode.make({ baseUrl, headers: authHeaders });
   };
 
   const createAndPrompt = async ({ sanitizedInput } = {}) => {
@@ -99,19 +150,34 @@ export const createConversationsService = (deps) => {
     const client = clientOrError;
 
     // Phase 1: create session (30s timeout)
-    let sessionResult;
-    let upstreamStatus;
+    let session;
     const createT = timeoutSignal(CREATE_TIMEOUT_MS);
     try {
-      sessionResult = await client.session.create({
-        directory: sanitizedInput.directory,
+      session = await client.session.create({
+        location: { directory: sanitizedInput.directory },
         ...(sanitizedInput.title ? { title: sanitizedInput.title } : {}),
-        ...(sanitizedInput.parentID ? { parentID: sanitizedInput.parentID } : {}),
-        ...(sanitizedInput.metadata ? { metadata: sanitizedInput.metadata } : {}),
+        ...(sanitizedInput.agent ? { agent: sanitizedInput.agent } : {}),
+        ...(sanitizedInput.model ? {
+          model: {
+            id: sanitizedInput.model.modelID,
+            providerID: sanitizedInput.model.providerID,
+            ...(sanitizedInput.variant ? { variant: sanitizedInput.variant } : {}),
+          },
+        } : {}),
       }, {
         signal: createT.signal,
       });
     } catch (error) {
+      const status = getHttpStatus(error);
+      if (Number.isFinite(status) && !isTransportError(error)) {
+        logger.warn(`[conversations] session.create client error (${status})`);
+        return {
+          ok: false,
+          phase: 'create',
+          error: safeErrorMessage('create'),
+          status,
+        };
+      }
       logger.warn('[conversations] session.create transport error');
       return {
         ok: false,
@@ -122,19 +188,7 @@ export const createConversationsService = (deps) => {
       createT.clear();
     }
 
-    upstreamStatus = sessionResult?.response?.status;
-
-    if (sessionResult.error) {
-      logger.warn(`[conversations] session.create SDK error (${upstreamStatus || 'no status'})`);
-      return {
-        ok: false,
-        phase: 'create',
-        error: safeErrorMessage('create'),
-        ...(Number.isFinite(upstreamStatus) ? { status: upstreamStatus } : {}),
-      };
-    }
-
-    const sessionID = sessionResult?.data?.id;
+    const sessionID = session?.id;
     if (!sessionID) {
       logger.warn('[conversations] session.create returned no session ID');
       return {
@@ -144,29 +198,17 @@ export const createConversationsService = (deps) => {
       };
     }
 
-    const session = sessionResult?.data;
-
-    // Phase 2: promptAsync (45s timeout, 204, does not wait for model completion)
+    // Phase 2: v2 prompt + delivery=steer (45s timeout). Host only orchestrates
+    // create + first prompt; it does not cache message body as conversation content.
     let promptResult;
     const promptT = timeoutSignal(PROMPT_TIMEOUT_MS);
     try {
-      promptResult = await client.session.promptAsync({
-        sessionID,
-        directory: sanitizedInput.directory,
-        messageID: sanitizedInput.messageID,
-        model: {
-          providerID: sanitizedInput.model.providerID,
-          modelID: sanitizedInput.model.modelID,
-        },
-        ...(sanitizedInput.agent ? { agent: sanitizedInput.agent } : {}),
-        ...(sanitizedInput.variant ? { variant: sanitizedInput.variant } : {}),
-        parts: sanitizedInput.parts,
-      }, {
+      promptResult = await client.session.prompt(toV2PromptInput(sanitizedInput, sessionID), {
         signal: promptT.signal,
       });
     } catch (error) {
-      const ambiguous = isTransportError(error);
-      logger.warn(`[conversations] promptAsync throw (ambiguous=${ambiguous})`);
+      const { ambiguous, status } = classifyPromptFailure(error);
+      logger.warn(`[conversations] prompt throw (ambiguous=${ambiguous})`);
       if (ambiguous) {
         safeMark(markUserMessageSent, sessionID, logger);
       }
@@ -177,37 +219,25 @@ export const createConversationsService = (deps) => {
         messageID: sanitizedInput.messageID,
         ambiguous,
         error: safeErrorMessage('prompt'),
+        ...(Number.isFinite(status) ? { status } : {}),
       };
     } finally {
       promptT.clear();
     }
 
     // SDK result shape { data, error, response }
-    if (promptResult.error) {
-      const httpStatus = promptResult.response?.status;
-      const ambiguous = isAmbiguousPromptError(promptResult.error, promptResult.response);
-      logger.warn(`[conversations] promptAsync SDK error (${httpStatus || 'no status'}, ambiguous=${ambiguous})`);
-      if (ambiguous) {
-        safeMark(markUserMessageSent, sessionID, logger);
-      }
-      return {
-        ok: false,
-        phase: 'prompt',
-        session,
-        messageID: sanitizedInput.messageID,
-        ambiguous,
-        error: safeErrorMessage('prompt'),
-        ...(Number.isFinite(httpStatus) ? { status: httpStatus } : {}),
-      };
-    }
-
-    // promptAsync 204 success
+    // prompt success — return inbox item when present; never persist parts/text.
     safeMark(markUserMessageSent, sessionID, logger);
 
+    const inbox = promptResult && typeof promptResult === 'object'
+      ? promptResult
+      : undefined;
+
     return {
       ok: true,
       session,
       messageID: sanitizedInput.messageID,
+      ...(inbox && (inbox.id || inbox.type) ? { inbox } : {}),
     };
   };
 

package/server/lib/conversations/service.test.js

@@ -1,15 +1,29 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
 import { validateConversationInput } from './validation.js';
 
-// Mock the SDK module before any imports
-vi.mock('@opencode-ai/sdk/v2', () => ({
-  createOpencodeClient: vi.fn(),
+// Mock the official v2 client before any imports
+vi.mock('@opencode/client', () => ({
+  OpenCode: { make: vi.fn() },
 }));
 
 // Lazy import to allow vi.mock to take effect
 const { createConversationsService } = await import('./service.js');
 
-const mockCreateOpencodeClient = (await import('@opencode-ai/sdk/v2')).createOpencodeClient;
+const mockMake = (await import('@opencode/client')).OpenCode.make;
+
+const clientError = (reason, cause) => {
+  const error = new Error(reason);
+  error.name = 'ClientError';
+  error.reason = reason;
+  if (cause !== undefined) error.cause = cause;
+  return error;
+};
+
+const httpError = (status, message) => {
+  const error = new Error(message);
+  error.status = status;
+  return error;
+};
 
 describe('conversations validation', () => {
   it('rejects non-object body', () => {
@@ -270,7 +284,7 @@ describe('conversations service', () => {
     mockBuildUrl.mockReturnValue('http://127.0.0.1:4096/');
     mockGetHeaders.mockReturnValue({ Authorization: 'Basic test' });
     mockWaitReady.mockResolvedValue(undefined);
-    mockCreateOpencodeClient.mockReset();
+    mockMake.mockReset();
   });
 
   const baseInput = (overrides = {}) => ({
@@ -295,9 +309,9 @@ describe('conversations service', () => {
   // --- create failures ---
 
   it('returns create failure with safe error when SDK returns error', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: null, error: new Error('internal: port 4096 unreachable'), response: { status: 500 } }),
+        create: async () => { throw clientError('UnexpectedStatus', { status: 500 }); },
       },
     });
     const service = createService();
@@ -311,7 +325,7 @@ describe('conversations service', () => {
   });
 
   it('returns create failure on transport error during create', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
         create: async () => { throw new Error('Connection refused'); },
       },
@@ -325,15 +339,19 @@ describe('conversations service', () => {
 
   // --- create: no agent/model ---
 
-  it('does NOT pass agent/model/variant to session.create', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+  it('passes agent/model/variant to session.create', async () => {
+    mockMake.mockReturnValue({
       session: {
         create: async (params) => {
-          expect(params.agent).toBeUndefined();
-          expect(params.model).toBeUndefined();
-          return { data: { id: 'ses_ok' }, error: null, response: { status: 200 } };
+          expect(params.agent).toBe('builder');
+          expect(params.model).toEqual({
+            id: 'gpt-4o',
+            providerID: 'openai',
+            variant: 'v1',
+          });
+          return { id: 'ses_ok' };
         },
-        promptAsync: async () => ({ data: undefined, error: null, response: { status: 204 } }),
+        prompt: async () => undefined,
       },
     });
     const service = createService();
@@ -343,42 +361,71 @@ describe('conversations service', () => {
     expect(result.ok).toBe(true);
   });
 
-  // --- promptAsync usage ---
+  // --- prompt usage ---
 
-  it('uses promptAsync (not prompt) and does not pass delivery', async () => {
-    let promptAsyncCalled = false;
-    mockCreateOpencodeClient.mockReturnValue({
+  it('uses prompt with delivery=steer and does not cache message body', async () => {
+    let promptCalled = false;
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_pa' }, error: null, response: { status: 200 } }),
-        promptAsync: async (params) => {
-          promptAsyncCalled = true;
-          expect(params.delivery).toBeUndefined();
-          return { data: undefined, error: null, response: { status: 204 } };
+        create: async () => ({ id: 'ses_pa' }),
+        prompt: async (params) => {
+          promptCalled = true;
+          expect(params.delivery).toBe('steer');
+          return {
+            id: 'msg_test',
+            sessionID: 'ses_pa',
+            type: 'user',
+            delivery: 'steer',
+            payload: { text: 'hello' },
+            timeCreated: 1,
+          };
         },
       },
     });
     const service = createService();
     const result = await service.createAndPrompt({ sanitizedInput: baseInput() });
-    expect(promptAsyncCalled).toBe(true);
+    expect(promptCalled).toBe(true);
     expect(result.ok).toBe(true);
+    expect(result.inbox).toEqual(expect.objectContaining({ id: 'msg_test', delivery: 'steer' }));
+    expect(result.parts).toBeUndefined();
+    expect(result.text).toBeUndefined();
   });
 
   // --- success ---
 
-  it('returns success when create + promptAsync succeed', async () => {
+  it('validates and forwards skill ids with the first prompt', async () => {
+    const validated = validateConversationInput({
+      input: { type: 'prompt' },
+      ...baseInput({ parts: [{ type: 'text', text: '[skill:release] prepare notes' }], skills: [{ id: 'release', text: 'untrusted body' }] }),
+    });
+    expect(validated.valid).toBe(true);
+    expect(validated.sanitized.skills).toEqual([{ id: 'release' }]);
+    const prompt = vi.fn(async () => undefined);
+    mockMake.mockReturnValue({ session: { create: async () => ({ id: 'ses_skill' }), prompt } });
+    const result = await createService().createAndPrompt({ sanitizedInput: validated.sanitized });
+    expect(result.ok).toBe(true);
+    expect(prompt.mock.calls[0][0]).toMatchObject({
+      text: '[skill:release] prepare notes', skills: [{ id: 'release', name: 'release' }], delivery: 'steer',
+    });
+  });
+
+  it('returns success when create + prompt succeed', async () => {
     const sessionData = { id: 'ses_created', title: 'Test' };
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
         create: async (params) => {
-          expect(params.directory).toBe('/test');
-          return { data: sessionData, error: null, response: { status: 200 } };
+          expect(params.location).toEqual({ directory: '/test' });
+          expect(params.model).toEqual({ id: 'gpt-4o', providerID: 'openai' });
+          return sessionData;
         },
-        promptAsync: async (params) => {
+        prompt: async (params) => {
           expect(params.sessionID).toBe('ses_created');
-          expect(params.messageID).toBe('msg_test');
-          expect(params.model).toEqual({ providerID: 'openai', modelID: 'gpt-4o' });
-          expect(params.parts).toEqual([{ type: 'text', text: 'hello' }]);
-          return { data: undefined, error: null, response: { status: 204 } };
+          expect(params.id).toBe('msg_test');
+          expect(params.text).toBe('hello');
+          expect(params.delivery).toBe('steer');
+          expect(params.model).toBeUndefined();
+          expect(params.parts).toBeUndefined();
+          return undefined;
         },
       },
     });
@@ -390,14 +437,19 @@ describe('conversations service', () => {
     expect(mockMarkSent).toHaveBeenCalledWith('ses_created');
   });
 
-  it('passes agent, variant to promptAsync', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+  it('passes agent, variant to session.create and not prompt', async () => {
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_avd' }, error: null, response: { status: 200 } }),
-        promptAsync: async (params) => {
+        create: async (params) => {
           expect(params.agent).toBe('builder');
-          expect(params.variant).toBe('fast');
-          return { data: undefined, error: null, response: { status: 204 } };
+          expect(params.model).toEqual({ id: 'gpt-4o', providerID: 'openai', variant: 'fast' });
+          return { id: 'ses_avd' };
+        },
+        prompt: async (params) => {
+          expect(params.agent).toBeUndefined();
+          expect(params.variant).toBeUndefined();
+          expect(params.delivery).toBe('steer');
+          return undefined;
         },
       },
     });
@@ -412,14 +464,10 @@ describe('conversations service', () => {
 
   it('returns prompt failure with ambiguous=false for 400 SDK error, safe error, no mark', async () => {
     const sessionData = { id: 'ses_400' };
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: sessionData, error: null, response: { status: 200 } }),
-        promptAsync: async () => ({
-          data: null,
-          error: new Error('path /foo/bar does not exist'),
-          response: { status: 400 },
-        }),
+        create: async () => sessionData,
+        prompt: async () => { throw httpError(400, 'path /foo/bar does not exist'); },
       },
     });
     const service = createService();
@@ -433,14 +481,10 @@ describe('conversations service', () => {
   });
 
   it('returns prompt failure with ambiguous=false for 404, no mark', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_404' }, error: null, response: { status: 200 } }),
-        promptAsync: async () => ({
-          data: null,
-          error: new Error('Session not found'),
-          response: { status: 404 },
-        }),
+        create: async () => ({ id: 'ses_404' }),
+        prompt: async () => { throw httpError(404, 'Session not found'); },
       },
     });
     const service = createService();
@@ -456,14 +500,10 @@ describe('conversations service', () => {
 
   it('returns ambiguous=true for 503, safe error, marks activity', async () => {
     const sessionData = { id: 'ses_503' };
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: sessionData, error: null, response: { status: 200 } }),
-        promptAsync: async () => ({
-          data: null,
-          error: new Error('Service Unavailable'),
-          response: { status: 503 },
-        }),
+        create: async () => sessionData,
+        prompt: async () => { throw clientError('UnexpectedStatus', { status: 503 }); },
       },
     });
     const service = createService();
@@ -477,10 +517,10 @@ describe('conversations service', () => {
   });
 
   it('returns ambiguous=true for transport throw, marks activity', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_transport' }, error: null, response: { status: 200 } }),
-        promptAsync: async () => { throw new TypeError('fetch failed'); },
+        create: async () => ({ id: 'ses_transport' }),
+        prompt: async () => { throw new TypeError('fetch failed'); },
       },
     });
     const service = createService();
@@ -493,14 +533,10 @@ describe('conversations service', () => {
   });
 
   it('returns ambiguous=true for 408, marks activity', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_408' }, error: null, response: { status: 200 } }),
-        promptAsync: async () => ({
-          data: null,
-          error: new Error('Request Timeout'),
-          response: { status: 408 },
-        }),
+        create: async () => ({ id: 'ses_408' }),
+        prompt: async () => { throw clientError('UnexpectedStatus', { status: 408 }); },
       },
     });
     const service = createService();
@@ -511,14 +547,10 @@ describe('conversations service', () => {
   });
 
   it('returns ambiguous=true for 429, marks activity', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_429' }, error: null, response: { status: 200 } }),
-        promptAsync: async () => ({
-          data: null,
-          error: new Error('Too Many Requests'),
-          response: { status: 429 },
-        }),
+        create: async () => ({ id: 'ses_429' }),
+        prompt: async () => { throw clientError('UnexpectedStatus', { status: 429 }); },
       },
     });
     const service = createService();
@@ -529,10 +561,10 @@ describe('conversations service', () => {
   });
 
   it('does NOT mark on non-transport, non-ambiguous throw', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_perm' }, error: null, response: { status: 200 } }),
-        promptAsync: async () => { throw new Error('Some permanent failure'); },
+        create: async () => ({ id: 'ses_perm' }),
+        prompt: async () => { throw new Error('Some permanent failure'); },
       },
     });
     const service = createService();
@@ -552,10 +584,10 @@ describe('conversations service', () => {
       markUserMessageSent: throwingMark,
       waitForOpenCodeReady: mockWaitReady,
     });
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_safe' }, error: null, response: { status: 200 } }),
-        promptAsync: async () => ({ data: undefined, error: null, response: { status: 204 } }),
+        create: async () => ({ id: 'ses_safe' }),
+        prompt: async () => undefined,
       },
     });
     const result = await svc.createAndPrompt({ sanitizedInput: baseInput() });
@@ -568,13 +600,13 @@ describe('conversations service', () => {
   it('passes directory/headers through buildOpenCodeUrl and getOpenCodeAuthHeaders', async () => {
     mockBuildUrl.mockReturnValue('http://custom:9999/');
     mockGetHeaders.mockReturnValue({ Authorization: 'Bearer secret123' });
-    mockCreateOpencodeClient.mockImplementation((config) => {
+    mockMake.mockImplementation((config) => {
       expect(config.baseUrl).toBe('http://custom:9999');
       expect(config.headers).toEqual({ Authorization: 'Bearer secret123' });
       return {
         session: {
-          create: async () => ({ data: { id: 'ses_url' }, error: null, response: { status: 200 } }),
-          promptAsync: async () => ({ data: undefined, error: null, response: { status: 204 } }),
+          create: async () => ({ id: 'ses_url' }),
+          prompt: async () => undefined,
         },
       };
     });
@@ -585,10 +617,10 @@ describe('conversations service', () => {
 
   it('awaits waitForOpenCodeReady before calling SDK', async () => {
     let createCalled = false;
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => { createCalled = true; return { data: { id: 'ses_w' }, error: null, response: { status: 200 } }; },
-        promptAsync: async () => ({ data: undefined, error: null, response: { status: 204 } }),
+        create: async () => { createCalled = true; return { id: 'ses_w' }; },
+        prompt: async () => undefined,
       },
     });
     const service = createService();
@@ -600,16 +632,16 @@ describe('conversations service', () => {
   // --- internal timeouts ---
 
   it('uses internal timeout signal for session.create', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
         create: async (_params, opts) => {
           expect(opts.signal).toBeDefined();
           expect(opts.signal.aborted).toBe(false);
-          return { data: { id: 'ses_to' }, error: null, response: { status: 200 } };
+          return { id: 'ses_to' };
         },
-        promptAsync: async (_params, opts) => {
+        prompt: async (_params, opts) => {
           expect(opts.signal).toBeDefined();
-          return { data: undefined, error: null, response: { status: 204 } };
+          return undefined;
         },
       },
     });
@@ -619,7 +651,7 @@ describe('conversations service', () => {
   });
 
   it('maps AbortError from create to create failure', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
         create: async () => { throw new DOMException('Aborted', 'AbortError'); },
       },
@@ -631,11 +663,11 @@ describe('conversations service', () => {
     expect(result.error).toBe('Failed to create session');
   });
 
-  it('maps AbortError from promptAsync to ambiguous=true', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+  it('maps AbortError from prompt to ambiguous=true', async () => {
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: { id: 'ses_pto' }, error: null, response: { status: 200 } }),
-        promptAsync: async () => { throw new DOMException('Aborted', 'AbortError'); },
+        create: async () => ({ id: 'ses_pto' }),
+        prompt: async () => { throw new DOMException('Aborted', 'AbortError'); },
       },
     });
     const service = createService();
@@ -649,9 +681,9 @@ describe('conversations service', () => {
   // --- create failure no session ID ---
 
   it('returns create failure when no session ID in response', async () => {
-    mockCreateOpencodeClient.mockReturnValue({
+    mockMake.mockReturnValue({
       session: {
-        create: async () => ({ data: null, error: null, response: { status: 200 } }),
+        create: async () => null,
       },
     });
     const service = createService();

package/server/lib/conversations/validation.js

@@ -1,6 +1,6 @@
 const ALLOWED_TOP_LEVEL_KEYS = new Set([
   'input', 'directory', 'messageID', 'model', 'parts',
-  'title', 'parentID', 'agent', 'variant', 'metadata',
+  'title', 'parentID', 'agent', 'variant', 'metadata', 'skills',
 ]);
 const ALLOWED_PART_TYPES = new Set(['text', 'file', 'agent']);
 
@@ -139,6 +139,15 @@ export const validateConversationInput = (body) => {
   }
 
   // Optional fields
+  let skills;
+  if (body.skills !== undefined) {
+    if (!Array.isArray(body.skills) || body.skills.some((skill) =>
+      !skill || typeof skill.id !== 'string' || !skill.id.trim())) {
+      errors.push('skills must be an array of non-empty skill ids');
+    } else {
+      skills = body.skills.map((skill) => ({ id: skill.id }));
+    }
+  }
   const title = asOptionalNonEmptyString(body.title);
   if (title === null) errors.push('title must be a non-empty string if provided');
 
@@ -168,6 +177,7 @@ export const validateConversationInput = (body) => {
         modelID: body.model.modelID.trim(),
       },
       parts: sanitizedParts,
+      ...(skills?.length ? { skills } : {}),
       title,
       parentID,
       agent,