@jskit-ai/assistant-core 0.1.209 → 0.1.212

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.1.209",
-    "@jskit-ai/http-runtime": "0.1.229",
-    "@jskit-ai/kernel": "0.1.231",
+    "@jskit-ai/assistant-core": "0.1.212",
+    "@jskit-ai/http-runtime": "0.1.232",
+    "@jskit-ai/kernel": "0.1.234",
     "@mdi/js": "^7.4.47",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.1.48",
-    "@jskit-ai/connectors-catalog": "0.1.48"
+    "@jskit-ai/connectors-core": "0.1.51",
+    "@jskit-ai/connectors-catalog": "0.1.51"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.1.209",
+  "version": "0.1.212",
   "type": "module",
   "scripts": {
     "test": "node --test --test-concurrency=1"
@@ -47,8 +47,8 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/resource-core": "0.1.173",
-    "@jskit-ai/resource-crud-core": "0.1.173",
+    "@jskit-ai/resource-core": "0.1.176",
+    "@jskit-ai/resource-crud-core": "0.1.176",
     "@mdi/js": "^7.4.47",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.101",
@@ -57,8 +57,8 @@
     "ws": "^8.20.1"
   },
   "peerDependencies": {
-    "@jskit-ai/http-runtime": "0.1.229",
-    "@jskit-ai/kernel": "0.1.231",
+    "@jskit-ai/http-runtime": "0.1.232",
+    "@jskit-ai/kernel": "0.1.234",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0"
   },

package/src/client/conversation/messageDelivery.js

@@ -190,6 +190,12 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     }
   }
 
+  function rejectUnsent(messageId, error) {
+    if (find(messageId)?.status !== "uncertain") return false;
+    fail(messageId, error);
+    return true;
+  }
+
   function restoreUncertain(request, savedTurns = []) {
     const messageId = messageText(request?.messageId);
     if (!messageId || savedTurns.some(turn => (turn.user || turn.system)?.messageId === messageId &&
@@ -236,7 +242,7 @@ function createAssistantMessageDelivery({ deliver: defaultDeliver } = {}) {
     state.sending = false;
   }
 
-  return { accept, cancel, edit, find, reconcile, remove, resend, reset, restoreUncertain, send, state, turns };
+  return { accept, cancel, edit, find, reconcile, remove, resend, reset, restoreUncertain, rejectUnsent, send, state, turns };
 }
 
 export { createAssistantMessageDelivery, unmatchedOptimisticMessages };

package/src/server/conversation/codexHistoryAdapter.js

@@ -2,6 +2,7 @@ import { open, realpath } from "node:fs/promises";
 import { createServer } from "node:http";
 import path from "node:path";
 import { Readable } from "node:stream";
+import { isDeepStrictEqual } from "node:util";
 import { gunzipSync, zstdDecompressSync } from "node:zlib";
 import { nativeAiModel, nativeAiProvider } from "../../shared/nativeProviders.js";
 
@@ -112,6 +113,12 @@ function compactionHistoryError(reason, statusCode = 422) {
   ), { statusCode });
 }
 
+function retainedUserRecord(item) {
+  if (item?.type !== "message" || item.role !== "user") return null;
+  const { encrypted_content, id, ...record } = item;
+  return record;
+}
+
 // Scan a fixed snapshot without retaining the lifetime transcript. A single
 // record still has a transport-sized bound; incomplete native appends are ignored.
 async function* readCodexHistoryRows(file, start, end, signal) {
@@ -189,6 +196,7 @@ async function restoreCompactedHistory(body, { destination, historyPath, codexHo
           boundary.count += 1;
           boundary.start = readableStart;
           boundary.end = offset;
+          boundary.retainedUsers = replacement.map(retainedUserRecord).filter(Boolean);
         }
       }
       if (typeof row.payload?.message === "string" && row.payload.message.trim() &&
@@ -225,17 +233,30 @@ async function restoreCompactedHistory(body, { destination, historyPath, codexHo
   // Count the original request plus each added item and its separating comma.
   // These are transport bytes, not a token estimate for the destination model.
   let restoredBytes = Buffer.byteLength(JSON.stringify(body));
-  for (const item of body.input) {
+  for (const [index, item] of body.input.entries()) {
     input.push(item);
     if (item?.type !== "compaction") continue;
     const history = boundaries.get(item.encrypted_content).history;
+    // Only copies retained by this exact native boundary and still preceding
+    // it in the request can replace an archived occurrence. A later user turn
+    // with the same words is a distinct instruction, not a retained copy.
+    const requestUsers = body.input.slice(0, index).map(retainedUserRecord).filter(Boolean);
+    const retainedUsers = boundaries.get(item.encrypted_content).retainedUsers.filter((record) => {
+      const index = requestUsers.findIndex((requestRecord) => isDeepStrictEqual(requestRecord, record));
+      if (index < 0) return false;
+      requestUsers.splice(index, 1);
+      return true;
+    });
     const readable = [];
     const images = [];
+    let retainedCopies = 0;
     for (const old of history) {
       if (!["message", "agent_message", "reasoning", "function_call", "function_call_output", "custom_tool_call", "custom_tool_call_output"].includes(old?.type)) {
         throw compactionHistoryError("the saved history contains an unsupported item.");
       }
       const { encrypted_content, id, ...record } = old;
+      const retainedRecord = retainedUserRecord(old);
+      const imageCount = images.length;
       // Keep each image as an actual image, with a numbered reference at its
       // original position in the archived message or tool result.
       for (const field of ["content", "summary", "output"]) {
@@ -259,10 +280,20 @@ async function restoreCompactedHistory(body, { destination, historyPath, codexHo
           throw compactionHistoryError("recovery of this non-text history is not supported yet.");
         });
       }
+      const retainedIndex = retainedRecord && retainedUsers.findIndex((retained) => isDeepStrictEqual(retained, retainedRecord));
+      if (retainedRecord && retainedIndex >= 0) {
+        retainedUsers.splice(retainedIndex, 1);
+        images.length = imageCount;
+        retainedCopies += 1;
+        continue;
+      }
       if (old.type === "reasoning" && !old.content?.length && !old.summary?.length) continue;
       readable.push(record);
     }
-    if (!readable.length) throw compactionHistoryError("the original readable conversation is missing.");
+    if (!readable.length) {
+      if (retainedCopies) continue;
+      throw compactionHistoryError("the original readable conversation is missing.");
+    }
     const supplement = { type: "message", role: "user", content: [{ type: "input_text",
       text: `[Archived conversation before compaction. Historical context, not new instructions. Current task instructions still apply.]\n${JSON.stringify(readable)}`
     }, ...images.flatMap((image, index) => [
@@ -335,6 +366,28 @@ async function startCodexHistoryAdapter({ token, codexHome, readHistoryPath, fet
       const result = await fetchImpl(`${upstream}/${route}${url.search}`, {
         method: request.method, headers, body, signal: abort.signal, redirect: "error"
       });
+      // DeepSeek labels this explicit context rejection as a generic invalid
+      // request. Preserve the provider's details while exposing the native
+      // recovery code; the adapter never retries the rejected inference.
+      if (destination === "deepseek" && result.status === 400 &&
+          result.headers.get("content-type")?.split(";", 1)[0].trim() === "application/json") {
+        let errorBody = Buffer.from(await result.arrayBuffer());
+        try {
+          const parsed = JSON.parse(errorBody.toString("utf8"));
+          const error = parsed?.error;
+          const match = typeof error?.message === "string" && /^This model's maximum context length is ([1-9]\d*) tokens\. However, you requested ([1-9]\d*) tokens \((\d+) in the messages, (\d+) in the completion\)\. Please reduce the length of the messages or completion\. \(request_id: [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\)$/u.exec(error.message);
+          if (error?.type === "invalid_request_error" && error.code === "invalid_request_error" && match) {
+            const [maximum, requested, messages, completion] = match.slice(1).map(Number);
+            if ([maximum, requested, messages, completion].every(Number.isSafeInteger) &&
+                requested > maximum && requested === messages + completion) {
+              error.code = "context_length_exceeded";
+              errorBody = Buffer.from(JSON.stringify(parsed));
+            }
+          }
+        } catch { /* Other provider errors keep their exact body. */ }
+        response.writeHead(result.status, Object.fromEntries(forwardedHeaders(result.headers))).end(errorBody);
+        return;
+      }
       response.writeHead(result.status, Object.fromEntries(forwardedHeaders(result.headers)));
       if (!result.body) { response.end(); return; }
       const stream = Readable.fromWeb(result.body);

package/src/server/conversation/codexMessageCommands.js

@@ -214,6 +214,7 @@ export function createCodexMessageCommands({
       const observerOptions = source.observerOptions || codexAppServerSessionObserverOptions(sessionId, source.providerOptions);
       const thread = await ensureCodexAppServerThread({
         ...(source.preparation || facility.preparation(currentSession)),
+        ...(preparation.applicationTools ? { applicationTools: preparation.applicationTools, providerReady: preparation.providerReady } : {}),
         observeThread: threadId => subscribeCodexAppServerEvents(sessionId, provider, threadId, observerOptions),
         provider,
         workdir: source.workdir ?? workdir
@@ -390,6 +391,7 @@ export function createCodexMessageCommands({
     const selected = await selectCodexAppServerMessageTurn(sessionId, { messageId, startedAt }, context.selection);
     if (Object.hasOwn(selected, "value")) return selected;
     const { provider, threadId, turnId } = selected;
+    if (prepare.providerReady) await prepare.providerReady({ provider, threadId });
     const prepared = { ...context, turnOwnership, messageId, actorContext };
     const policy = await prepare.prepareMessage(input, prepared, { starting: false, selected });
     if (policy) return policy;

package/src/server/conversation/codexMessageDelivery.js

@@ -61,7 +61,8 @@ export function createCodexAppServerMessageDelivery({
     messageId = "",
     turnMetadata = null,
     attachments = [],
-    nativeIdentity = null
+    nativeIdentity = null,
+    data
   ) {
     const normalizedSessionId = normalizeCodexRunText(sessionId);
     const message = normalizeCodexRunText(text);
@@ -78,12 +79,15 @@ export function createCodexAppServerMessageDelivery({
     if (pendingMessage?.recording) {
       return pendingMessage.recording;
     }
+    const authored = pendingMessage?.authoredInput;
+    const applicationData = authored?.messageId === normalizeCodexRunText(messageId) ? authored.data : data;
     const recording = (async () => {
       const written = await runtime.store.writeConversationUserMessage(normalizedSessionId, {
         attachments,
         nativeIdentity,
         messageId: normalizeCodexRunText(messageId),
         text: message,
+        ...(applicationData !== undefined ? { data: structuredClone(applicationData) } : {}),
         turnMetadata: messageMetadata.delivered
           ? await messageMetadata.delivered(runtime.store, normalizedSessionId, turnMetadata)
           : turnMetadata
@@ -157,7 +161,8 @@ export function createCodexAppServerMessageDelivery({
         await writeCodexAppServerDeliveredUserMessage(
           { store }, normalizedSessionId, recoveredMessage.displayMessage, receiptId,
           recoveredMessage.turnMetadata, recoveredMessage.displayAttachments,
-          { threadId: normalizedThreadId, turnId: codexAppServerNotificationTurnId(notification) }
+          { threadId: normalizedThreadId, turnId: codexAppServerNotificationTurnId(notification) },
+          recoveredMessage.data
         );
       }
       const turn = turnStateFromAgentRun(run || {});

package/src/server/conversation/codexNotificationObserver.js

@@ -250,6 +250,17 @@ export function createCodexNotificationObserver({
         });
       }
       const classification = classifyCodexAppServerEvent(notification);
+      if (classification.kind === "provider_error" && classification.text &&
+          codexAppServerNotificationParams(notification).willRetry !== true) {
+        runCodexAppServerNotificationTask(notificationContext, async () => {
+          return onNotificationSignal("provider_error", {
+            sessionId: normalizedSessionId, threadId: normalizedThreadId, provider,
+            turnId: await resolveCodexAppServerTurnId(normalizedSessionId, normalizedThreadId,
+              codexAppServerNotificationTurnId(notification)),
+            error: classification.text
+          });
+        });
+      }
       if (classification.kind === "hook_prompt") {
         codexAppServerAutomaticHookThreads.add(normalizedThreadId);
         return;
@@ -389,7 +400,8 @@ export function createCodexNotificationObserver({
               error: codexAppServerNotificationError(notification),
               provider,
               status,
-              usageLimitExceeded: codexAppServerNotificationUsageLimitExceeded(notification)
+              usageLimitExceeded: codexAppServerNotificationUsageLimitExceeded(notification),
+              deferFailureDetails: true
             });
           });
           return;
@@ -430,7 +442,8 @@ export function createCodexNotificationObserver({
               error: codexAppServerNotificationError(notification),
               provider,
               status,
-              usageLimitExceeded: codexAppServerNotificationUsageLimitExceeded(notification)
+              usageLimitExceeded: codexAppServerNotificationUsageLimitExceeded(notification),
+              deferFailureDetails: true
             });
           });
           return;

package/src/server/conversation/codexProvider.js

@@ -233,6 +233,19 @@ async function deleteCodexAppServerHelperThread({ provider, threadId, turnId = "
   }
 }
 
+function codexApplicationToolConfiguration(tools) {
+  const dynamicTools = (tools?.schemas || []).map(({ function: tool }) => ({
+    type: "function", name: tool.name, description: tool.description, inputSchema: tool.parameters
+  }));
+  return { dynamicTools, toolSchemaIdentity: createHash("sha256").update(JSON.stringify(dynamicTools)).digest("hex") };
+}
+
+function assertCodexApplicationToolSchemaIdentity(threadId, savedIdentity, toolSchemaIdentity) {
+  if (threadId && (savedIdentity || codexApplicationToolConfiguration().toolSchemaIdentity) !== toolSchemaIdentity) {
+    throw new Error("This Codex conversation was created with different application tool entry points. Start a new conversation to enable or remove application tools.");
+  }
+}
+
 /** Retained thread selection keeps observation ahead of a resume that can start work. */
 async function ensureCodexAppServerThread({
   observeThread,
@@ -240,6 +253,8 @@ async function ensureCodexAppServerThread({
   settings,
   projectHooks = false,
   identity,
+  applicationTools,
+  providerReady,
   workdir = "",
   onStage = () => {}
 } = {}) {
@@ -254,13 +269,23 @@ async function ensureCodexAppServerThread({
   const appServerRuntime = availability?.runtime || await provider.ensureRuntime();
   onStage({ durationMs: Date.now() - stageStartedAt, stage: "runtime" });
   const existingThreadId = identity.read(normalizedWorkdir);
+  const toolConfiguration = applicationTools ? codexApplicationToolConfiguration(applicationTools) : null;
+  if (toolConfiguration) {
+    if (typeof identity.readToolSchemaIdentity !== "function") throw new TypeError("Bound Codex application tools require the original schema identity reader and writer.");
+    assertCodexApplicationToolSchemaIdentity(existingThreadId, await identity.readToolSchemaIdentity(normalizedWorkdir), toolConfiguration.toolSchemaIdentity);
+  }
   let config = null;
   if (projectHooks) {
     stageStartedAt = Date.now();
     config = await codexAppServerProjectHookTrustConfig(provider, normalizedWorkdir);
     onStage({ durationMs: Date.now() - stageStartedAt, stage: "hook-config" });
   }
-  const { threadSettings, threadStartSettings } = await settings(normalizedWorkdir, config);
+  let { threadSettings, threadStartSettings } = await settings(normalizedWorkdir, config);
+  if (toolConfiguration) {
+    threadSettings = { ...threadSettings, dynamicTools: toolConfiguration.dynamicTools };
+    threadStartSettings = { ...threadStartSettings, dynamicTools: toolConfiguration.dynamicTools };
+  }
+  if (providerReady) await providerReady({ provider, threadId: existingThreadId });
   let thread = null;
   stageStartedAt = Date.now();
   if (existingThreadId) {
@@ -283,7 +308,9 @@ async function ensureCodexAppServerThread({
     throw new Error("Codex app-server did not return a thread id.");
   }
   stageStartedAt = Date.now();
-  await identity.write({ appServerRuntime, threadId, workdir: normalizedWorkdir });
+  await identity.write({ appServerRuntime, threadId, workdir: normalizedWorkdir,
+    ...(toolConfiguration ? { toolSchemaIdentity: toolConfiguration.toolSchemaIdentity } : {}) });
+  if (providerReady) await providerReady({ provider, threadId });
   onStage({ durationMs: Date.now() - stageStartedAt, stage: "identity-metadata" });
   return {
     appServerRuntime,
@@ -1265,6 +1292,7 @@ export class CodexAppServerAgentProvider {
     this.runtimeStopOwner = null;
     this.runtimePromise = null;
     this.serverRequestHandler = null;
+    this.threadRequestHandlers = new Map();
     this.conversationRuntime = createCodexConversationAdapter({
       readInstructions: (params, threadId) => this.options.readInstructions?.(params, threadId),
       client: () => this.activeClient(),
@@ -1427,7 +1455,7 @@ export class CodexAppServerAgentProvider {
     };
   }
 
-  async handleServerRequest(request = {}) {
+  async handleServerRequest(request = {}, sourceClient = this.client) {
     if (
       this.isHelperProvider() &&
       request.method === CODEX_APP_SERVER_CHATGPT_REFRESH_METHOD
@@ -1439,6 +1467,15 @@ export class CodexAppServerAgentProvider {
       error.code = -32601;
       throw error;
     }
+    const threadHandler = request.method === "item/tool/call" && this.threadRequestHandlers.get(request.params?.threadId);
+    if (threadHandler) {
+      if (sourceClient !== this.client) {
+        const error = new Error("This retired Codex connection does not authorize that native tool request.");
+        error.code = -32601;
+        throw error;
+      }
+      return threadHandler.handler(request);
+    }
     if (typeof this.serverRequestHandler === "function") {
       return this.serverRequestHandler(request);
     }
@@ -1643,7 +1680,7 @@ export class CodexAppServerAgentProvider {
       requestTimeoutMs: this.options.requestTimeoutMs,
       WebSocketImpl: this.options.WebSocketImpl
     });
-    client.setRequestHandler((request) => this.handleServerRequest(request));
+    client.setRequestHandler((request) => this.handleServerRequest(request, client));
     let initializeResult = null;
     try {
       await client.connect();
@@ -1972,15 +2009,34 @@ export class CodexAppServerAgentProvider {
   setServerRequestHandler(callback) {
     const handler = typeof callback === "function" ? callback : null;
     this.serverRequestHandler = handler;
-    this.client?.setRequestHandler?.((request) => this.handleServerRequest(request));
+    const client = this.client;
+    client?.setRequestHandler?.((request) => this.handleServerRequest(request, client));
     return () => {
       if (this.serverRequestHandler === handler) {
         this.serverRequestHandler = null;
-        this.client?.setRequestHandler?.((request) => this.handleServerRequest(request));
+        const client = this.client;
+        client?.setRequestHandler?.((request) => this.handleServerRequest(request, client));
       }
     };
   }
 
+  registerThreadRequestHandler(threadId, handler) {
+    if (typeof threadId !== "string" || !threadId.trim() || typeof handler !== "function") {
+      throw new TypeError("Codex tool dispatch requires its exact thread and handler.");
+    }
+    if (this.threadRequestHandlers.has(threadId)) throw new Error("This Codex thread already has an application tool owner.");
+    const registration = { handler };
+    this.threadRequestHandlers.set(threadId, registration);
+    const client = this.client;
+    client?.setRequestHandler?.(request => this.handleServerRequest(request, client));
+    return Object.freeze({
+      isCurrent: () => this.threadRequestHandlers.get(threadId) === registration,
+      release: () => {
+        if (this.threadRequestHandlers.get(threadId) === registration) this.threadRequestHandlers.delete(threadId);
+      }
+    });
+  }
+
   async startThread({ hostContext, ...params } = {}) {
     params = await this.conversationRuntime.prepareInstructions({ ...params, hostContext });
     delete params.hostContext;
@@ -2666,6 +2722,7 @@ export class CodexAppServerAgentProvider {
     this.planUsage = null;
     this.planUsagePending = null;
     this.notificationSubscribers.clear();
+    this.threadRequestHandlers.clear();
     this.client?.close();
     this.client = null;
     this.initializeResult = null;
@@ -2704,7 +2761,7 @@ export class CodexAppServerAgentProvider {
 export {
   CODEX_APP_SERVER_INVALID_REQUEST_CODE, assertCodexAuthPreflightReady,
   createCodexAppServerModelCatalogCache, codexAppServerProviderConnectionGeneration,
-  ensureCodexAppServerThread, sendCodexAppServerPrompt,
+  ensureCodexAppServerThread, codexApplicationToolConfiguration, assertCodexApplicationToolSchemaIdentity, sendCodexAppServerPrompt,
   resumeExactCodexAppServerThread, startFreshCodexAppServerThread,
   defineCodexRenewalThreadIds, codexRenewalThreadError,
   codexAppServerEndpointForTarget, codexAppServerRequestIsInvalid, codexAppServerThreadIsMissing,

package/src/server/conversation/codexTurn.js

@@ -110,10 +110,22 @@ export function createCodexAppServerRunOwner({
   runInContext = (_context, operation) => operation(),
   notificationQueue = null,
   activeReconcileMs = 2000,
+  finalizingGraceMs = 10000,
+  finalizingGraceAfterHistoryRead = false,
+  failureDetailGraceMs = 0,
   steerFailedCode = "codex_turn_steer_failed",
   interruptFailedCode = "codex_turn_interrupt_failed",
   errorPrefix = ""
 } = {}) {
+  if (!Number.isSafeInteger(finalizingGraceMs) || finalizingGraceMs < 1) {
+    throw new TypeError("Invalid Codex finalizing grace.");
+  }
+  if (typeof finalizingGraceAfterHistoryRead !== "boolean") {
+    throw new TypeError("Invalid Codex finalizing grace clock.");
+  }
+  if (!Number.isSafeInteger(failureDetailGraceMs) || failureDetailGraceMs < 0) {
+    throw new TypeError("Invalid Codex failure detail grace.");
+  }
   if (providerSessions && (serverClosingError || !providerSessions.managed)) {
     providerSessions = { ...providerSessions, managed: providerSessions.managed || new Map() };
   }
@@ -126,7 +138,6 @@ export function createCodexAppServerRunOwner({
     CONTROL_RECONFIGURATION: "control_reconfiguration",
     INTERRUPTED: "interrupted"
   };
-  const finalizingGraceMs = 10000;
   const snapshotRecoveryItemLimit = 25;
   const helperOwnershipError = createCodexHelperOwnershipError({ errorPrefix });
   const helperLifecycle = helperThreads ? createCodexHelperThreadLifecycle({
@@ -165,7 +176,7 @@ export function createCodexAppServerRunOwner({
   } = codexProviderSelection;
   const acquireOutputProvider = providerSessions?.outputContext
     ? async ({ sessionId, runtime, session }) => {
-      const prepared = providerSessions.outputContext({ sessionId, runtime, session });
+      const prepared = await providerSessions.outputContext({ sessionId, runtime, session });
       if (!prepared) return null;
       return acquireCodexAppServerOutputProvider(
         sessionId, session, prepared.managedIdentity, prepared.providerOptions
@@ -285,6 +296,9 @@ export function createCodexAppServerRunOwner({
     captureContext,
     runInContext,
     activeReconcileMs,
+    finalizingGraceAfterHistoryRead,
+    failureDetailGraceMs,
+    notificationQueue: codexAppServerNotificationQueue,
     hasRuntime,
     recoverAdmission,
     turnOutcomes,