@agentknight/sdk 0.9.46 → 0.9.48

package/dist/chunks/{codex-adapter-IR5E7AMV.js → codex-adapter-5XC3CAAT.js}

@@ -1,15 +1,15 @@
 import {
   latestPreviewItems
-} from "./chunk-QBKKQQCB.js";
+} from "./chunk-6VEMXJW4.js";
 import {
   UnsupportedAgentOperationError
-} from "./chunk-7A2SQAZ7.js";
+} from "./chunk-R5LSWHRH.js";
 import {
   ConversationItemSchema,
   InteractionRequestSchema,
   SESSION_TIMELINE_PAGE_SIZE,
   SessionSummarySchema
-} from "./chunk-DUMC5F2D.js";
+} from "./chunk-BDKVGENQ.js";
 
 // src/codex-adapter.ts
 import { randomUUID } from "node:crypto";
@@ -300,6 +300,7 @@ var NativeItem = z3.object({
 var NativeTurn = z3.object({
   id: NativeId,
   status: z3.enum(["inProgress", "completed", "interrupted", "failed"]),
+  startedAt: z3.number().nullable().optional(),
   items: z3.array(NativeItem)
 });
 var ThreadResult = z3.object({
@@ -342,8 +343,8 @@ function base(threadId, turnId, nativeId) {
     sourceEventIds: [nativeId]
   };
 }
-function projectItem(threadId, turnId, item, completed) {
-  const common = base(threadId, turnId, item.id);
+function projectItem(threadId, turnId, item, completed, timestamp) {
+  const common = { ...base(threadId, turnId, item.id), ...timestamp === void 0 ? {} : { timestamp } };
   switch (item.type) {
     case "userMessage":
       return ConversationItemSchema.parse({
@@ -394,7 +395,8 @@ var StoredSession = z4.object({
   summary: SessionSummarySchema,
   modelId: z4.string(),
   items: z4.array(ConversationItemSchema),
-  uncertain: z4.boolean()
+  uncertain: z4.boolean(),
+  native: z4.boolean().optional()
 });
 var Inventory = z4.object({
   version: z4.literal(1),
@@ -415,6 +417,8 @@ var CodexCodingAgentAdapter = class {
   #identity;
   #directory;
   #sessions = /* @__PURE__ */ new Map();
+  #discovered = /* @__PURE__ */ new Map();
+  #retiredSessions = /* @__PURE__ */ new Set();
   #pending = /* @__PURE__ */ new Map();
   #callbacks;
   #rpc;
@@ -434,6 +438,9 @@ var CodexCodingAgentAdapter = class {
     const command = options.command ?? "codex";
     if (!command.trim() || command.includes("\0")) throw new Error("Invalid Codex executable");
     this.#options = { ...options, command, args: [...options.args ?? ["app-server"]] };
+    if (options.nativeSessionOwner !== void 0) {
+      SessionSummarySchema.pick({ userId: true, machineId: true }).parse(options.nativeSessionOwner);
+    }
     this.#identity = hash(JSON.stringify([options.ownerId ?? "host", command, this.#options.args]));
     this.#directory = join2(resolve(options.dataDirectory), "codex", this.#identity);
   }
@@ -526,6 +533,8 @@ var CodexCodingAgentAdapter = class {
     }
     this.#rpc = void 0;
     this.#sessions.clear();
+    this.#discovered.clear();
+    this.#retiredSessions.clear();
   }
   setSessionCallbacks(callbacks) {
     this.#callbacks = callbacks;
@@ -538,13 +547,13 @@ var CodexCodingAgentAdapter = class {
   }
   #known(id, requireShared = true) {
     this.#ready();
-    const session = this.#sessions.get(id);
+    const session = this.#sessions.get(id) ?? this.#discovered.get(id);
     if (!session) throw new Error("Unknown or unowned Codex session");
     if (requireShared && !session.summary.isRemote) throw new Error("Codex session is not shared");
     return session;
   }
   isSessionVisible(id) {
-    return this.#started && this.#sessions.get(id)?.summary.isRemote === true;
+    return this.#started && (this.#sessions.get(id) ?? this.#discovered.get(id))?.summary.isRemote === true;
   }
   async #native() {
     this.#ready();
@@ -606,11 +615,12 @@ var CodexCodingAgentAdapter = class {
         const snapshot = JSON.stringify({
           version: 1,
           identity: this.#identity,
-          sessions: [...this.#sessions.values()].map(({ summary, modelId, items, uncertain }) => ({
+          sessions: [...this.#sessions.values()].map(({ summary, modelId, items, uncertain, native }) => ({
             summary,
             modelId,
             items,
-            uncertain
+            uncertain,
+            ...native === void 0 ? {} : { native }
           }))
         });
         const staging = join2(this.#directory, `inventory-${randomUUID()}.tmp`);
@@ -647,6 +657,11 @@ var CodexCodingAgentAdapter = class {
   }
   async listSessions(userId, machineId) {
     this.#ready();
+    const owner = this.#options.nativeSessionOwner;
+    if (owner !== void 0 && owner.userId === userId && owner.machineId === machineId) {
+      await this.#scanNative(owner);
+      return [...this.#sessions.values(), ...this.#discovered.values()].filter((session) => session.summary.userId === userId && session.summary.machineId === machineId && session.summary.isRemote).map((session) => ({ ...session.summary })).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+    }
     const owned = [...this.#sessions.values()].filter((s) => s.summary.userId === userId && s.summary.machineId === machineId && s.summary.isRemote);
     const rpc = this.#rpc;
     if (owned.length && rpc && !rpc.closed && !this.#opening && !this.#fatal) {
@@ -690,6 +705,79 @@ var CodexCodingAgentAdapter = class {
       (s) => s.summary.userId === userId && s.summary.machineId === machineId && s.summary.isRemote
     ).map((s) => ({ ...s.summary })).sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
   }
+  async #scanNative(owner) {
+    const rpc = await this.#native();
+    const next = /* @__PURE__ */ new Map();
+    const seen = /* @__PURE__ */ new Set();
+    const present = /* @__PURE__ */ new Set();
+    let cursor = null;
+    do {
+      const result = z4.object({
+        data: z4.array(z4.object({
+          id: NativeId,
+          name: z4.string().nullable().optional(),
+          preview: z4.string(),
+          cwd: z4.string(),
+          createdAt: z4.number(),
+          updatedAt: z4.number(),
+          model: z4.string().nullable().optional()
+        })),
+        nextCursor: z4.string().nullable()
+      }).parse(await rpc.request("thread/list", { cursor, limit: 100, sortKey: "updated_at", useStateDbOnly: true }));
+      this.#ready();
+      for (const entry of result.data) {
+        present.add(entry.id);
+        this.#retiredSessions.delete(entry.id);
+        const existing = this.#sessions.get(entry.id) ?? this.#discovered.get(entry.id);
+        if (existing && (existing.summary.userId !== owner.userId || existing.summary.machineId !== owner.machineId)) {
+          throw new Error("Codex native thread belongs to another PC owner");
+        }
+        const summary = SessionSummarySchema.parse({
+          ...owner,
+          sessionId: entry.id,
+          summary: (entry.name || entry.preview).slice(0, 4096),
+          workingDirectory: entry.cwd,
+          createdAt: new Date(entry.createdAt * 1e3).toISOString(),
+          modifiedAt: new Date(entry.updatedAt * 1e3).toISOString(),
+          isRemote: existing?.summary.isRemote ?? true,
+          renameSupported: false
+        });
+        if (existing) {
+          existing.summary = summary;
+          if (!this.#sessions.has(entry.id)) next.set(entry.id, existing);
+        } else {
+          next.set(entry.id, this.#runtime({
+            summary,
+            modelId: entry.model || CODEX_DEFAULT_MODEL_ID,
+            items: [],
+            uncertain: false,
+            native: true
+          }));
+        }
+      }
+      cursor = result.nextCursor;
+      if (cursor !== null) {
+        if (seen.has(cursor) || seen.size >= 100) throw new Error("Codex native thread pagination did not terminate");
+        seen.add(cursor);
+      }
+    } while (cursor !== null);
+    for (const id of this.#discovered.keys()) {
+      if (!next.has(id) && !this.#sessions.has(id)) this.#retiredSessions.add(id);
+    }
+    this.#discovered.clear();
+    for (const [id, session] of next) {
+      if (!this.#sessions.has(id)) this.#discovered.set(id, session);
+    }
+    let removed = false;
+    for (const [id, session] of this.#sessions) {
+      if (session.native && !present.has(id) && !session.active && !session.sending && !session.queue.length && !session.uncertain && !session.aborting && this.#operations === 0) {
+        this.#sessions.delete(id);
+        this.#retiredSessions.add(id);
+        removed = true;
+      }
+    }
+    if (removed) await this.#save();
+  }
   async listModels(sessionId) {
     if (sessionId) this.#known(sessionId);
     this.#operations++;
@@ -798,12 +886,18 @@ var CodexCodingAgentAdapter = class {
   async setSessionRemote(id, enabled) {
     const session = this.#known(id, false);
     session.summary.isRemote = enabled;
+    if (this.#discovered.has(id)) {
+      this.#sessions.set(id, session);
+      this.#discovered.delete(id);
+    }
     if (!enabled) await this.#abort(session);
     await this.#save();
     this.#events?.onSessionInventoryChanged(id);
     return this.getSessionRemoteStatus(id);
   }
-  async watchSession(id, _watched) {
+  async watchSession(id, watched) {
+    this.#ready();
+    if (!watched && this.#retiredSessions.has(id)) return;
     this.#known(id);
   }
   async readSessionPlan(_id) {
@@ -819,6 +913,16 @@ var CodexCodingAgentAdapter = class {
     const session = this.#known(id);
     const size = options.pageSize ?? SESSION_TIMELINE_PAGE_SIZE;
     if (!Number.isInteger(size) || size < 1 || size > SESSION_TIMELINE_PAGE_SIZE) throw new RangeError("Invalid timeline page size");
+    if (session.native && !session.active && !session.sending && !session.queue.length) {
+      await this.#locked(session, async () => {
+        if (session.active || session.sending || session.queue.length) return;
+        const rpc = await this.#native();
+        const result = ThreadResult.parse(await rpc.request("thread/read", { threadId: id, includeTurns: true }));
+        this.#known(id);
+        if (result.thread.id !== id) throw new Error("Codex returned history for another native thread");
+        this.#importHistory(session, result.thread.turns);
+      });
+    }
     let end = session.items.length;
     let cursorStatus = "ok";
     if (options.cursor !== void 0) {
@@ -835,6 +939,29 @@ var CodexCodingAgentAdapter = class {
       cursorStatus
     };
   }
+  #importHistory(session, turns, publish = false) {
+    const previous = new Map(session.items.map((item) => [item.id, item]));
+    const items = [];
+    const updates = [];
+    for (const turn of turns) {
+      const timestamp = turn.startedAt == null ? session.summary.createdAt : new Date(turn.startedAt * 1e3).toISOString();
+      for (const native of turn.items) {
+        const old = previous.get(itemId(session.summary.sessionId, native.id));
+        const projected = projectItem(session.summary.sessionId, turn.id, native, turn.status !== "inProgress", old?.timestamp ?? timestamp);
+        if (!projected) continue;
+        const item = { ...projected, revision: old?.revision ?? 1 };
+        const changed = JSON.stringify(item) !== JSON.stringify(old);
+        if (old && changed) item.revision++;
+        items.push(item);
+        previous.delete(item.id);
+        if (changed) updates.push(item);
+      }
+    }
+    session.items = [...items, ...[...previous.values()].filter((item) => publish || item.kind === "notice")];
+    if (publish && session.summary.isRemote) {
+      for (const item of updates) this.#events?.onConversationItem(session.summary.sessionId, structuredClone(item));
+    }
+  }
   #locked(session, run) {
     this.#operations++;
     const work = session.lock.then(run);
@@ -851,12 +978,19 @@ var CodexCodingAgentAdapter = class {
     const threadId = session.summary.sessionId;
     const read = ThreadResult.parse(await rpc.request("thread/read", { threadId, includeTurns: true }));
     if (read.thread.id !== threadId || !["idle", "notLoaded"].includes(read.thread.status.type) || read.thread.turns.some((turn) => turn.status === "inProgress")) {
-      session.uncertain = true;
-      await this.#save();
+      if (!session.native) {
+        session.uncertain = true;
+        await this.#save();
+      }
       throw new Error("Codex owned thread is not verifiably idle; refusing to attach");
     }
     this.#known(threadId);
     if (session.aborting) throw new Error("Codex resume cancelled");
+    if (session.native && this.#discovered.has(threadId)) {
+      this.#sessions.set(threadId, session);
+      this.#discovered.delete(threadId);
+      await this.#save();
+    }
     const resumed = ThreadResult.parse(await rpc.request("thread/resume", {
       threadId,
       cwd: session.summary.workingDirectory,
@@ -869,13 +1003,9 @@ var CodexCodingAgentAdapter = class {
       await this.#save();
       throw new Error("Codex resume did not confirm an idle owned thread");
     }
-    for (const turn of resumed.thread.turns) {
-      for (const item of turn.items) {
-        const projected = projectItem(threadId, turn.id, item, turn.status !== "inProgress");
-        if (projected) this.#upsert(session, projected);
-      }
-    }
+    this.#importHistory(session, resumed.thread.turns, true);
     session.loaded = true;
+    await this.#save();
   }
   async sendPrompt(id, prompt, mode, attachments = [], _persistInteractions = true, files = [], _operationId, persona) {
     const session = this.#known(id);
@@ -958,6 +1088,8 @@ var CodexCodingAgentAdapter = class {
     });
   }
   async abortSession(id) {
+    this.#ready();
+    if (this.#retiredSessions.has(id)) return;
     await this.#abort(this.#known(id));
   }
   async #abort(session) {

package/dist/chunks/{copilot-adapter-7IACBBQ6.js → copilot-adapter-RSL5GJYO.js}

@@ -18,25 +18,25 @@ import {
   recordTimelineSyncDiagnostic,
   resolveGitProjectIdentity,
   sanitizeGitRemoteUrl
-} from "./chunk-MUKGV7IE.js";
+} from "./chunk-RX7VGB3T.js";
 import {
   assertMainSessionId,
   isResearchSessionId
-} from "./chunk-TKIZWXMQ.js";
+} from "./chunk-2QHOQXOR.js";
 import {
   GroupChatError,
   GroupChatMessageSchema,
   GroupChatRuntime
-} from "./chunk-OPUBIQCO.js";
+} from "./chunk-H6FG5CCS.js";
 import {
   isContentfulAssistant
-} from "./chunk-QBKKQQCB.js";
+} from "./chunk-6VEMXJW4.js";
 import {
   AgentSessionRenameError,
   SessionOperationError,
   TimelinePageBudgetError,
   validateSessionName
-} from "./chunk-7A2SQAZ7.js";
+} from "./chunk-R5LSWHRH.js";
 import {
   ConversationItemSchema,
   CopilotModelOptionSchema,
@@ -57,7 +57,7 @@ import {
   WorkbenchScheduleEntrySchema,
   WorkbenchScheduleProposalSchema,
   WorkbenchScheduleSnapshotSchema
-} from "./chunk-DUMC5F2D.js";
+} from "./chunk-BDKVGENQ.js";
 
 // src/copilot-adapter.ts
 import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
@@ -4114,7 +4114,7 @@ var GithubCopilotAdapter = class {
     resolveImages: (sessionId, session, normalizer, readOnly) => this.#images.resolveTimelineImageAssets(sessionId, session, normalizer, readOnly)
   });
   agentId = "copilot";
-  sdkVersion = "1.0.11";
+  sdkVersion = "1.0.26";
   agentModes = ["interactive", "plan", "autopilot"];
   supportsReasoningEffort = true;
   #upgradeSessionIds = /* @__PURE__ */ new Set();

package/dist/chunks/{managed-agent-adapter-UYLBGRNG.js → managed-agent-adapter-GTFFRVMM.js}

@@ -1,13 +1,13 @@
 import {
   AgentSelectionSchema,
   assertSelectionSnapshotFits
-} from "./chunk-DCY33KQC.js";
+} from "./chunk-YFLDTX2W.js";
 import {
   isResearchSessionId
-} from "./chunk-TKIZWXMQ.js";
+} from "./chunk-2QHOQXOR.js";
 import {
   GroupChatError
-} from "./chunk-OPUBIQCO.js";
+} from "./chunk-H6FG5CCS.js";
 import {
   AgentModelListingError,
   AgentSessionRenameError,
@@ -16,11 +16,11 @@ import {
   UnsupportedAgentOperationError,
   captureWorkbenchAccess,
   validateSessionName
-} from "./chunk-7A2SQAZ7.js";
+} from "./chunk-R5LSWHRH.js";
 import {
   InteractionResponseSchema,
   SessionSummarySchema
-} from "./chunk-DUMC5F2D.js";
+} from "./chunk-BDKVGENQ.js";
 
 // src/managed-agent-adapter.ts
 import { createHash, randomUUID } from "node:crypto";

package/dist/chunks/{pi-adapter-5PZT5YQN.js → pi-adapter-WGHEJ5WA.js}

@@ -1,16 +1,16 @@
 import {
   latestPreviewItems
-} from "./chunk-QBKKQQCB.js";
+} from "./chunk-6VEMXJW4.js";
 import {
   AgentSessionRenameError,
   UnsupportedAgentOperationError,
   validateSessionName
-} from "./chunk-7A2SQAZ7.js";
+} from "./chunk-R5LSWHRH.js";
 import {
   InteractionRequestSchema,
   REASONING_EFFORTS,
   SESSION_TIMELINE_PAGE_SIZE
-} from "./chunk-DUMC5F2D.js";
+} from "./chunk-BDKVGENQ.js";
 
 // src/pi-adapter.ts
 import { createHash as createHash2, randomUUID } from "node:crypto";
@@ -113,6 +113,7 @@ var PiTimeline = class {
     return `pi:${key(`${this.sessionId}:${signature}:${index}`)}`;
   }
   #message(message, id, final) {
+    if (message.role === "system") return;
     const timestamp = new Date(message.timestamp).toISOString();
     if (message.role === "user") this.#turnId = id;
     if (message.role === "user" || message.role === "assistant") {
@@ -771,6 +772,7 @@ var PiCodingAgentAdapter = class {
     this.#assertOpening(sessionId);
     const cancellation = (pi) => {
       const cancelled = () => this.#stopping || this.#cancelledOpenings.has(sessionId) || this.#runtimes.get(sessionId)?.aborting === true;
+      pi.on("input", () => cancelled() ? { action: "handled" } : void 0);
       pi.on("session_before_compact", () => cancelled() ? { cancel: true } : void 0);
       pi.on("session_before_tree", () => cancelled() ? { cancel: true } : void 0);
     };
@@ -924,11 +926,7 @@ var PiCodingAgentAdapter = class {
       runtime.primarySource = prompt;
       return runtime.session.prompt(prompt.text, {
         expandPromptTemplates: false,
-        source: "rpc",
-        // PI awaits compaction/extensions before Agent.prompt; cancellation must survive preflight.
-        preflightResult: (accepted) => {
-          if (accepted && (runtime.aborting || this.#stopping)) throw new Error("PI prompt was aborted before execution.");
-        }
+        source: "rpc"
       });
     }).catch((error) => {
       this.#error(runtime, error);

package/dist/index.d.ts

@@ -1934,7 +1934,7 @@ declare const PeerChatResultSchema: z.ZodObject<{
 type PeerChatResult = z.infer<typeof PeerChatResultSchema>;
 
 type RelayRegistrationStatus = {
-    readonly state: "connecting" | "error";
+    readonly state: "connecting" | "disconnected" | "error";
     readonly message: string;
 } | {
     readonly state: "registered";
@@ -1992,6 +1992,8 @@ interface Agent {
     readonly isStopping: boolean;
     readonly identityHash: string;
     start(): Promise<void>;
+    reconnectRelay(): void;
+    disconnectRelay(): void;
     stop(): Promise<void>;
     waitUntilStopped(): Promise<void>;
     getUpgradeStatus(): Promise<{
@@ -2006,7 +2008,7 @@ interface Agent {
     runPeerChat(request: PeerChatRequest, signal: AbortSignal): Promise<PeerChatResult>;
     setPeerChatEnabled(enabled: boolean): Promise<void>;
     getStatus(): Promise<{
-        state: "initialized" | "connecting" | "ready" | "error" | "stopped";
+        state: "initialized" | "connecting" | "disconnected" | "ready" | "error" | "stopped";
         busy: boolean;
     }>;
 }