@openchambery/web 1.19.7-beta.8 → 1.19.7

package/server/lib/opencode/proxy.js

@@ -11,6 +11,15 @@ import {
   extractDirectoryFromRequest,
   isDirectoryTurnAdmissionPath,
 } from './instance-recovery-runtime.js';
+import {
+  createReasoningOutboundFilter,
+  createSseBlockSplitter,
+  filterSseBlock,
+  projectMessagesPayloadForReasoning,
+  readIncludeReasoningFromUrl,
+  readIncludeReasoningQuery,
+  stripIncludeReasoningParam,
+} from '../event-stream/reasoning-projection.js';
 
 export const createDirectoryQueryCanonicalizer = ({ realpath, ...cacheOptions } = {}) => {
   const realpathCache = createRealpathCache({ fallbackOnError: true, realpath, ...cacheOptions });
@@ -379,6 +388,14 @@ export const registerOpenCodeProxy = (app, deps) => {
     let connectTimedOut = false;
     let writeQueue = Promise.resolve(true);
     const sseBoundary = createSseBoundaryTracker();
+    const requestUrl = typeof req.originalUrl === 'string' && req.originalUrl.length > 0
+      ? req.originalUrl
+      : (typeof req.url === 'string' ? req.url : '');
+    // OpenChamber projection control — never forwarded to OpenCode.
+    const includeReasoning = readIncludeReasoningQuery(req.query)
+      && readIncludeReasoningFromUrl(requestUrl);
+    const reasoningFilter = includeReasoning ? null : createReasoningOutboundFilter();
+    const sseSplitter = includeReasoning ? null : createSseBlockSplitter();
 
     req.on('close', closeUpstream);
 
@@ -400,10 +417,9 @@ export const registerOpenCodeProxy = (app, deps) => {
     };
 
     try {
-      const requestUrl = typeof req.originalUrl === 'string' && req.originalUrl.length > 0
-        ? req.originalUrl
-        : (typeof req.url === 'string' ? req.url : '');
-      const upstreamPath = requestUrl.startsWith('/api') ? requestUrl.slice(4) || '/' : requestUrl;
+      // Strip includeReasoning before building the upstream OpenCode path.
+      const strippedUrl = stripIncludeReasoningParam(requestUrl);
+      const upstreamPath = strippedUrl.startsWith('/api') ? strippedUrl.slice(4) || '/' : strippedUrl;
       const headers = normalizeForwardedDirectoryHeaders(
         collectForwardProxyHeaders(req.headers, getOpenCodeAuthHeaders())
       );
@@ -495,10 +511,40 @@ export const registerOpenCodeProxy = (app, deps) => {
         }
         if (value && value.length > 0) {
           resetStallTimer();
-          sseBoundary.observe(value);
-          const canContinue = await enqueueSseWrite(value);
-          if (!canContinue) {
-            break;
+          if (includeReasoning) {
+            // Enabled path: byte-identical passthrough (existing behavior).
+            sseBoundary.observe(value);
+            const canContinue = await enqueueSseWrite(value);
+            if (!canContinue) {
+              break;
+            }
+          } else {
+            // Disabled path: parse SSE blocks, drop reasoning, re-serialize.
+            // Preserves id/event lines and GlobalEvent wrap when unchanged drop-only.
+            const blocks = sseSplitter.push(value);
+            let canContinue = true;
+            for (const block of blocks) {
+              const filtered = filterSseBlock(block, reasoningFilter);
+              if (!filtered) {
+                continue;
+              }
+              sseBoundary.observe(filtered);
+              canContinue = await enqueueSseWrite(filtered);
+              if (!canContinue) break;
+            }
+            if (!canContinue) {
+              break;
+            }
+          }
+        }
+      }
+
+      if (!includeReasoning && sseSplitter) {
+        for (const block of sseSplitter.finish()) {
+          const filtered = filterSseBlock(block, reasoningFilter);
+          if (filtered) {
+            sseBoundary.observe(filtered);
+            await enqueueSseWrite(filtered);
           }
         }
       }
@@ -524,6 +570,7 @@ export const registerOpenCodeProxy = (app, deps) => {
     } finally {
       clearConnectTimer();
       clearStallTimer();
+      reasoningFilter?.dispose?.();
       if (heartbeatTimer) {
         clearTimeout(heartbeatTimer);
         heartbeatTimer = null;
@@ -584,7 +631,7 @@ export const registerOpenCodeProxy = (app, deps) => {
 
   const forwardSanitizedSessionListRequest = async (req, res, next, logLabel) => {
     try {
-      const upstreamPath = await getRequestUpstreamPath(req);
+      const upstreamPath = stripIncludeReasoningParam(await getRequestUpstreamPath(req));
       const result = await fetchSessionListPayload(upstreamPath, { req });
 
       res.status(result.upstream.status);
@@ -617,6 +664,47 @@ export const registerOpenCodeProxy = (app, deps) => {
     }
   };
 
+  /**
+   * Official session.messages list (`GET /api/session/:id/message`).
+   * When includeReasoning=false, strip reasoning parts from the JSON body.
+   * includeReasoning is never forwarded upstream.
+   */
+  const forwardSessionMessagesListRequest = async (req, res, next) => {
+    try {
+      const includeReasoning = readIncludeReasoningQuery(req.query);
+      const upstreamPath = stripIncludeReasoningParam(await getRequestUpstreamPath(req));
+      const result = await fetchSessionListPayload(upstreamPath, { req });
+
+      res.status(result.upstream.status);
+      applyForwardProxyResponseHeaders(result.upstream.headers, res);
+
+      if (!result.isJson) {
+        res.setHeader('content-type', result.contentType);
+        res.end(result.bodyText);
+        return;
+      }
+
+      if (result.parseError || result.payload == null) {
+        res.setHeader('content-type', result.contentType);
+        res.end(result.bodyText);
+        return;
+      }
+
+      res.setHeader('content-type', result.contentType);
+      res.json(projectMessagesPayloadForReasoning(result.payload, includeReasoning));
+    } catch (error) {
+      if (isAbortError(error)) {
+        return;
+      }
+      console.error('[proxy] OpenCode session.messages proxy error:', error?.message ?? error);
+      if (!res.headersSent) {
+        res.status(503).json({ error: 'OpenCode service unavailable' });
+        return;
+      }
+      next(error);
+    }
+  };
+
   // Ensure API prefix is detected before proxying
   app.use('/api', (_req, _res, next) => {
     ensureOpenCodeApiPrefix();
@@ -776,6 +864,12 @@ export const registerOpenCodeProxy = (app, deps) => {
     return forwardSanitizedSessionListRequest(req, res, next, 'session.list');
   });
 
+  // Official session.messages list (not exact message — that is owned by
+  // session-turn-pages and registered before this proxy).
+  app.get('/api/session/:sessionID/message', (req, res, next) => {
+    return forwardSessionMessagesListRequest(req, res, next);
+  });
+
   app.get('/api/global/event', forwardSseRequest);
   app.get('/api/event', forwardSseRequest);
 

package/server/lib/opencode/proxy.test.js

@@ -1,12 +1,69 @@
-import { describe, expect, it } from 'vitest';
+import express from 'express';
+import request from 'supertest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import {
   createDirectoryQueryCanonicalizer,
   isInteractiveSessionRequest,
   normalizeForwardedDirectoryHeaders,
+  registerOpenCodeProxy,
   resolveSessionTurnAdmissionRequest,
 } from './proxy.js';
 
+const originalFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  vi.restoreAllMocks();
+});
+
+const readyRuntime = () => ({
+  isOpenCodeReady: true,
+  openCodeNotReadySince: 0,
+  isRestartingOpenCode: false,
+  openCodePort: 4096,
+  openCodeBaseUrl: 'http://127.0.0.1:4096',
+});
+
+const mountProxy = () => {
+  const app = express();
+  // Fresh app each time — registerOpenCodeProxy guards on app setting.
+  registerOpenCodeProxy(app, {
+    fs: { promises: { realpath: async (v) => v } },
+    os: {},
+    path: {},
+    OPEN_CODE_READY_GRACE_MS: 1000,
+    LONG_REQUEST_TIMEOUT_MS: 60_000,
+    SSE_UPSTREAM_CONNECT_TIMEOUT_MS: 5_000,
+    SSE_UPSTREAM_STALL_TIMEOUT_MS: 5_000,
+    getRuntime: readyRuntime,
+    getOpenCodeAuthHeaders: () => ({}),
+    buildOpenCodeUrl: (path) => `http://127.0.0.1:4096${path}`,
+    ensureOpenCodeApiPrefix: () => {},
+  });
+  return app;
+};
+
+const sseBody = (blocks) => {
+  const encoder = new TextEncoder();
+  const text = blocks.join('');
+  let sent = false;
+  return {
+    getReader() {
+      return {
+        async read() {
+          if (sent) return { done: true, value: undefined };
+          sent = true;
+          return { done: false, value: encoder.encode(text) };
+        },
+        async cancel() {},
+        releaseLock() {},
+      };
+    },
+    async cancel() {},
+  };
+};
+
 describe('createDirectoryQueryCanonicalizer', () => {
   it('canonicalizes directory query params and preserves other params', async () => {
     const canonicalize = createDirectoryQueryCanonicalizer({
@@ -124,3 +181,122 @@ describe('resolveSessionTurnAdmissionRequest', () => {
     expect(resolveSessionTurnAdmissionRequest({ method: 'POST', url: '/api/session/ses_1/message' })).toBeNull();
   });
 });
+
+describe('registerOpenCodeProxy reasoning projection routes', () => {
+  it('strips includeReasoning from SSE upstream and drops reasoning events when false', async () => {
+    const upstreamUrls = [];
+    globalThis.fetch = vi.fn(async (url) => {
+      upstreamUrls.push(String(url));
+      return {
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'content-type': 'text/event-stream' }),
+        body: sseBody([
+          'id: 1\ndata: {"type":"message.part.updated","properties":{"part":{"id":"t","messageID":"m","type":"text","text":"hi"}}}\n\n',
+          'id: 2\ndata: {"type":"session.next.reasoning.delta.1","properties":{"delta":"secret"}}\n\n',
+          'id: 3\ndata: {"type":"message.part.delta","properties":{"messageID":"m","partID":"t","field":"text","delta":"!"}}\n\n',
+        ]),
+      };
+    });
+
+    const app = mountProxy();
+    const res = await request(app)
+      .get('/api/event?directory=%2Ftmp&includeReasoning=false')
+      .buffer(true)
+      .parse((response, callback) => {
+        const chunks = [];
+        response.on('data', (c) => chunks.push(Buffer.from(c)));
+        response.on('end', () => callback(null, Buffer.concat(chunks).toString('utf8')));
+      });
+
+    expect(res.status).toBe(200);
+    expect(upstreamUrls).toHaveLength(1);
+    expect(upstreamUrls[0]).not.toContain('includeReasoning');
+    expect(upstreamUrls[0]).toContain('directory=');
+    expect(res.body).toContain('"type":"message.part.updated"');
+    expect(res.body).toContain('"type":"message.part.delta"');
+    expect(res.body).not.toContain('reasoning');
+    expect(res.body).not.toContain('secret');
+  });
+
+  it('byte-passthrough SSE when includeReasoning is omitted', async () => {
+    const raw =
+      'id: 1\ndata: {"type":"session.next.reasoning.delta","properties":{"delta":"keep"}}\n\n';
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      headers: new Headers({ 'content-type': 'text/event-stream' }),
+      body: sseBody([raw]),
+    }));
+
+    const app = mountProxy();
+    const res = await request(app)
+      .get('/api/global/event')
+      .buffer(true)
+      .parse((response, callback) => {
+        const chunks = [];
+        response.on('data', (c) => chunks.push(Buffer.from(c)));
+        response.on('end', () => callback(null, Buffer.concat(chunks).toString('utf8')));
+      });
+
+    expect(res.status).toBe(200);
+    expect(res.body).toContain('session.next.reasoning.delta');
+    expect(res.body).toContain('keep');
+  });
+
+  it('filters session.messages list JSON and strips includeReasoning upstream', async () => {
+    const upstreamUrls = [];
+    globalThis.fetch = vi.fn(async (url) => {
+      upstreamUrls.push(String(url));
+      return {
+        ok: true,
+        status: 200,
+        headers: new Headers({ 'content-type': 'application/json' }),
+        async text() {
+          return JSON.stringify([
+            {
+              info: { id: 'msg_1', tokens: { reasoning: 12 } },
+              parts: [
+                { id: 'r', type: 'reasoning', text: 'hidden' },
+                { id: 't', type: 'text', text: 'visible' },
+              ],
+            },
+          ]);
+        },
+      };
+    });
+
+    const app = mountProxy();
+    const res = await request(app)
+      .get('/api/session/ses_1/message?limit=30&includeReasoning=false&directory=%2Frepo');
+
+    expect(res.status).toBe(200);
+    expect(upstreamUrls[0]).not.toContain('includeReasoning');
+    expect(upstreamUrls[0]).toContain('/session/ses_1/message');
+    expect(res.body[0].parts).toEqual([{ id: 't', type: 'text', text: 'visible' }]);
+    expect(res.body[0].info.tokens.reasoning).toBe(12);
+    expect(JSON.stringify(res.body)).not.toContain('hidden');
+  });
+
+  it('keeps reasoning parts on session.messages list when includeReasoning is omitted', async () => {
+    globalThis.fetch = vi.fn(async () => ({
+      ok: true,
+      status: 200,
+      headers: new Headers({ 'content-type': 'application/json' }),
+      async text() {
+        return JSON.stringify([
+          {
+            info: { id: 'msg_1' },
+            parts: [{ id: 'r', type: 'reasoning', text: 'keep-me' }],
+          },
+        ]);
+      },
+    }));
+
+    const app = mountProxy();
+    const res = await request(app).get('/api/session/ses_1/message');
+    expect(res.status).toBe(200);
+    expect(res.body[0].parts[0].type).toBe('reasoning');
+    expect(res.body[0].parts[0].text).toBe('keep-me');
+  });
+});

package/server/lib/opencode/settings-runtime.js

@@ -666,8 +666,8 @@ export const createSettingsRuntime = (deps) => {
       return { settings, changed: false };
     }
 
-    const defaultLight = 'flexoki-light';
-    const defaultDark = 'flexoki-dark';
+    const defaultLight = 'carbonfox-light';
+    const defaultDark = 'vitesse-dark-dark';
 
     let nextLightThemeId = hasLight ? settings.lightThemeId : undefined;
     let nextDarkThemeId = hasDark ? settings.darkThemeId : undefined;