@stigmer/sdk 2.0.0 → 3.0.0

package/src/gen/session.ts

@@ -9,7 +9,7 @@ import { ToolApprovalOverrideSchema, McpServerUsageSchema } from "@stigmer/proto
 import { SessionSchema, type Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import { SessionCommandController } from "@stigmer/protos/ai/stigmer/agentic/session/v1/command_pb";
 import { Harness, CursorMode, ExecutionTarget, GitWriteBackMode } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
-import { SessionIdSchema, UpdateSessionSubjectRequestSchema, UpdateSessionMemoryRequestSchema, ListSessionsRequestSchema, SessionListSchema, ListSessionsByAgentRequestSchema, type UpdateSessionSubjectRequest, type UpdateSessionMemoryRequest, type ListSessionsRequest, type SessionList, type ListSessionsByAgentRequest } from "@stigmer/protos/ai/stigmer/agentic/session/v1/io_pb";
+import { SessionIdSchema, UpdateSessionSubjectRequestSchema, ListSessionsRequestSchema, SessionListSchema, ListSessionsByAgentRequestSchema, type UpdateSessionSubjectRequest, type ListSessionsRequest, type SessionList, type ListSessionsByAgentRequest } from "@stigmer/protos/ai/stigmer/agentic/session/v1/io_pb";
 import { SessionQueryController } from "@stigmer/protos/ai/stigmer/agentic/session/v1/query_pb";
 import { SessionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/spec_pb";
 import { GitRepoSourceSchema, LocalPathSourceSchema, WorkspaceSourceSchema, WorkspaceEntrySchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
@@ -51,12 +51,6 @@ export class SessionClient {
     } catch (e) { throw wrapError(e); }
   }
 
-  async updateSessionMemory(input: UpdateSessionMemoryRequest): Promise<Session> {
-    try {
-      return await this.command.updateSessionMemory(input);
-    } catch (e) { throw wrapError(e); }
-  }
-
   async delete(id: string): Promise<Session> {
     try {
       return await this.command.delete(create(SessionIdSchema, { value: id }));

package/src/index.ts

@@ -4,7 +4,11 @@
 export { Stigmer } from "./stigmer";
 
 // Runner adapter
-export { type RunnerAdapter } from "./runner-adapter";
+export {
+  type RunnerAdapter,
+  type RunnerWorkerHost,
+  createRunnerAdapter,
+} from "./runner-adapter";
 
 // Configuration
 export { type StigmerConfig, type TokenProvider } from "./config";
@@ -177,6 +181,17 @@ export {
 
 // Session utilities (hand-written)
 export { PENDING_SUBJECT, resolvedSubject } from "./session";
+
+// Tool-call view model (framework-agnostic; shared by @stigmer/react and @stigmer/ink)
+export {
+  ToolKind,
+  resolveToolKind,
+  resolveToolKindByName,
+  normalizeToolResult,
+  type ToolResultView,
+  type ToolSearchMatch,
+  type ToolContentBlock,
+} from "./execution/tool-view";
 export { SkillClient, type SkillInput } from "./gen/skill";
 export {
   WorkflowClient,

package/src/runner-adapter.ts

@@ -1,3 +1,6 @@
+// The framework-agnostic RunnerAdapter contract plus the createRunnerAdapter
+// construction helper. Canonical home for both; @stigmer/react re-exports them.
+
 /**
  * Framework-agnostic RunnerAdapter interface.
  *
@@ -8,14 +11,77 @@
  * When `executionTarget` is `"local"`, SDK clients automatically call
  * the adapter at the appropriate lifecycle points. The consumer never
  * needs to manage runner processes directly.
+ *
+ * Sessions and workflow executions have different lifecycles. A session
+ * is a long-lived, multi-turn conversation with no terminal phase, so its
+ * worker is tied to whether the session is open (in use): `onSessionOpened`
+ * when the session is opened, `onSessionClosed` when it is closed. A
+ * workflow execution runs to a terminal phase, so its worker is tied to
+ * creation and completion.
  */
 export interface RunnerAdapter {
-  /** Called after a session is created with executionTarget=LOCAL. */
-  onSessionCreated(sessionId: string): Promise<void>;
-  /** Called when a session reaches a terminal phase. */
-  onSessionTerminated(sessionId: string): Promise<void>;
+  /**
+   * Called when a local session is opened (engaged). The adapter should
+   * ensure a runner worker is polling the session's task queue. Idempotent:
+   * may be called again for an already-open session (e.g. on re-open).
+   */
+  onSessionOpened(sessionId: string): Promise<void>;
+  /**
+   * Called when a local session is closed (no longer in use). The adapter
+   * should tear down the session's runner worker.
+   */
+  onSessionClosed(sessionId: string): Promise<void>;
   /** Called after a workflow execution is created with executionTarget=LOCAL. */
   onWorkflowExecutionCreated(executionId: string): Promise<void>;
   /** Called when a workflow execution reaches a terminal phase. */
   onWorkflowExecutionTerminated(executionId: string): Promise<void>;
 }
+
+/**
+ * A runner backend that can start and stop per-session and per-execution
+ * workers. This is the worker-lifecycle slice of a runner host — the only
+ * capability `createRunnerAdapter` needs — not the full process surface
+ * (start/status/token/shutdown).
+ *
+ * Several backends already satisfy this shape structurally: the in-process
+ * `StigmerRunnerManager` (`@stigmer/runner`), the desktop's embedded-runner
+ * context (Tauri IPC), and any custom runner-management API. Pass one to
+ * `createRunnerAdapter` to get a wired {@link RunnerAdapter}.
+ */
+export interface RunnerWorkerHost {
+  // Return Promise<unknown>, not Promise<void>: a Promise<string> (e.g. the
+  // desktop returns the worker's task queue) is not assignable to Promise<void>,
+  // so void would reject real hosts. The factory awaits and discards the value.
+  addSession(sessionId: string): Promise<unknown>;
+  removeSession(sessionId: string): Promise<unknown>;
+  addWorkflowExecution(executionId: string): Promise<unknown>;
+  removeWorkflowExecution(executionId: string): Promise<unknown>;
+}
+
+/**
+ * Build a {@link RunnerAdapter} that delegates to a {@link RunnerWorkerHost},
+ * collapsing the per-embedder boilerplate of wiring lifecycle events to worker
+ * management into a single call.
+ *
+ * The adapter does not add its own state: idempotency and deduplication are the
+ * host's responsibility (the SDK calls `onSessionOpened` on every open).
+ */
+export function createRunnerAdapter(host: RunnerWorkerHost): RunnerAdapter {
+  // The mapping is deliberate and asymmetric: sessions attach/detach on
+  // open/close, workflow executions on create/terminate. Keep it here so no
+  // embedder re-derives (and mis-wires) it.
+  return {
+    onSessionOpened: async (sessionId) => {
+      await host.addSession(sessionId);
+    },
+    onSessionClosed: async (sessionId) => {
+      await host.removeSession(sessionId);
+    },
+    onWorkflowExecutionCreated: async (executionId) => {
+      await host.addWorkflowExecution(executionId);
+    },
+    onWorkflowExecutionTerminated: async (executionId) => {
+      await host.removeWorkflowExecution(executionId);
+    },
+  };
+}