operon-agents 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/extensions/manager.d.ts

@@ -44,6 +44,8 @@ export interface StagingOptions {
     /** The extension's data folder, already created. */
     readonly dataDir?: string;
     createSession: ExtensionHostContext["createSession"];
+    /** Resolve one of the definition's `uses` names to its service handle. */
+    service(name: string): unknown;
     warn(message: string): void;
 }
 /**

package/dist/extensions/manager.js

@@ -33,6 +33,7 @@ export function stageDefinition(definition, options) {
         return { sessionDef: definition };
     const host = {
         createSession: (sessionOptions) => options.createSession(sessionOptions),
+        services: Object.freeze(Object.fromEntries((definition.uses ?? []).map((name) => [name, options.service(name)]))),
         ...(options.dir !== undefined ? { dir: options.dir } : {}),
         ...(options.dataDir !== undefined ? { dataDir: options.dataDir } : {}),
         warn: (message) => options.warn(`[extension ${definition.id}] ${message}`),
@@ -170,6 +171,7 @@ export class HarnessExtensionManager {
             dir: await this.loader.manifestDir(definition.id),
             dataDir,
             createSession: (sessionOptions) => this.bridge.createSession(sessionOptions),
+            service: (name) => this.bridge.services.handle(name),
             warn: (message) => this.bridge.warn(message),
         });
     }

package/dist/extensions/types.d.ts

@@ -516,10 +516,11 @@ export interface ExtensionAPI {
 /**
  * What an extension's `create` half is handed — the harness reach it needs to build a
  * process-shared instance. Deliberately narrow: session creation (a spawn factory's one
- * requirement) and a data directory (the file form's own folder; absent by value). No
- * service-registration call: the instance IS the return value, registered under the extension's `id`.
+ * requirement), a data directory (the file form's own folder; absent by value) and the handles
+ * of the services it declared in `uses`. No service-registration call: the instance IS the
+ * return value, registered under the extension's `id`.
  */
-export interface ExtensionHostContext {
+export interface ExtensionHostContext<TServices extends Readonly<Record<string, unknown>> = Readonly<Record<string, unknown>>> {
     /** Open a brand-new session on this harness — what a spawn factory calls. */
     createSession(options?: {
         readonly title?: string;
@@ -528,6 +529,14 @@ export interface ExtensionHostContext {
     } & Record<string, unknown>): Promise<{
         readonly id: string;
     }>;
+    /**
+     * Handles to the services named in `uses`, by name — the same handles `setup` gets as
+     * `ctx.services`, available to the process half too. What lets a file-loaded bundle take its
+     * configuration from a host-registered service (`createHarness({ services })`) instead of
+     * baking it in: a reload re-runs `create`, so re-reading the service IS the config update.
+     * Method calls resolve the CURRENT provider; the handles expose methods only.
+     */
+    readonly services: TServices;
     /** The extension's own folder when it was file-loaded; `undefined` when passed by value.
      *  Code only — an update replaces it wholesale. Keep files in `dataDir`. */
     readonly dir?: string;
@@ -584,7 +593,7 @@ export interface ExtensionDefinition<TShared = unknown, TParams = unknown, TServ
     /** Per-handler invocation budget. Defaults to 30s for decision points, 1s for observers. */
     readonly timeoutMs?: number;
     /** The process-shared half. Absent ⇒ an ordinary per-session extension. See above. */
-    create?(host: ExtensionHostContext): TShared | Promise<TShared>;
+    create?(host: ExtensionHostContext<TServices>): TShared | Promise<TShared>;
     /** Services this extension consumes, by name — other extensions' `create` results (their
      *  `id`s) or host-registered `services`. Resolved into `ctx.services` for `setup`. */
     readonly uses?: readonly (keyof TServices & string)[];

package/dist/harness.d.ts

@@ -27,6 +27,21 @@ export interface DeliveryOptions {
     /** auto: steer a running turn, or start an idle one. */
     readonly mode?: DeliveryMode;
 }
+/**
+ * Provenance a worker hands `dispatchAccepted` for an input whose acceptance is already
+ * journaled. `user` / `user_follow_up`: the user's own words, delivered on their behalf by the
+ * party holding the session's control surface (a managed API caller) — rendered bare, filed as
+ * steering / follow-up. `external`: another party's words, rendered inside the envelope.
+ */
+export type AcceptedOrigin = (SteerOrigin & {
+    readonly kind: "external";
+}) | {
+    readonly kind: "user";
+    readonly deliveryId: string;
+} | {
+    readonly kind: "user_follow_up";
+    readonly deliveryId: string;
+};
 export interface DeliveryReceipt {
     readonly deliveryId: string;
     readonly sessionId: string;
@@ -445,9 +460,7 @@ export declare class HarnessSession<TContext = unknown> {
      * Run state is read HERE, not at acceptance: by now a turn may have started or ended, so
      * whether this steers work in flight or starts a fresh turn can only be decided now.
      */
-    dispatchAccepted(input: string, origin: SteerOrigin & {
-        readonly kind: "external";
-    }, acceptedAt?: number): DeliveryReceipt;
+    dispatchAccepted(input: string, origin: AcceptedOrigin, acceptedAt?: number): DeliveryReceipt;
     /**
      * Resume a durably-interrupted run. When a `prompt` returns `status:"interrupted"` — which
      * happens when no live approval handler is registered (`no live responder ⇒ durable`) — the run's
@@ -564,6 +577,7 @@ export declare class HarnessSession<TContext = unknown> {
     setPluginMcpServerEnabled(...args: Parameters<Session["setPluginMcpServerEnabled"]>): ReturnType<Session["setPluginMcpServerEnabled"]>;
     removePlugin(...args: Parameters<Session["removePlugin"]>): ReturnType<Session["removePlugin"]>;
     reloadPlugins(...args: Parameters<Session["reloadPlugins"]>): ReturnType<Session["reloadPlugins"]>;
+    listMcpTools(...args: Parameters<Session["listMcpTools"]>): ReturnType<Session["listMcpTools"]>;
     listMcpServers(...args: Parameters<Session["listMcpServers"]>): ReturnType<Session["listMcpServers"]>;
     reconnectMcpServer(...args: Parameters<Session["reconnectMcpServer"]>): ReturnType<Session["reconnectMcpServer"]>;
     /** Close the session and release its resources. */

package/dist/harness.js

@@ -415,7 +415,9 @@ export class HarnessSession {
         if (this.closed)
             throw new Error(`session "${this.id}" is closed`);
         const deliveryId = origin.deliveryId;
-        const channel = origin.channel ?? "steering";
+        const channel = origin.kind === "external"
+            ? origin.channel ?? "steering"
+            : origin.kind === "user_follow_up" ? "follow_up" : "steering";
         if (this.currentRun !== undefined) {
             const receipt = this.core.steer.steer(input, origin);
             return {
@@ -427,13 +429,17 @@ export class HarnessSession {
                 steerId: receipt.steerId,
             };
         }
-        const promptOrigin = {
-            kind: "external",
-            source: origin.source,
-            deliveryId,
-            ...(origin.actor !== undefined ? { actor: origin.actor } : {}),
-            ...(origin.metadata !== undefined ? { metadata: origin.metadata } : {}),
-        };
+        // A fresh turn is a fresh prompt: a follow-up landing on an idle session is simply the
+        // user's next prompt, so it is journaled as `user`, not `user_follow_up`.
+        const promptOrigin = origin.kind === "external"
+            ? {
+                kind: "external",
+                source: origin.source,
+                deliveryId,
+                ...(origin.actor !== undefined ? { actor: origin.actor } : {}),
+                ...(origin.metadata !== undefined ? { metadata: origin.metadata } : {}),
+            }
+            : { kind: "user", deliveryId };
         const message = {
             role: "user",
             content: [{ type: "text", text: renderSteerText(origin, input) }],
@@ -798,6 +804,9 @@ export class HarnessSession {
         return this.core.reloadPlugins(...args);
     }
     // ── MCP ──
+    listMcpTools(...args) {
+        return this.core.listMcpTools(...args);
+    }
     listMcpServers(...args) {
         return this.core.listMcpServers(...args);
     }
@@ -931,6 +940,7 @@ export class Harness {
                     }
                     return this.createSession(sessionOptions);
                 },
+                service: (name) => this.services.handle(name),
                 warn: (message) => console.warn(`[extensions] ${message}`),
             });
             return staged instanceof Promise ? staged.then(done, failed) : done(staged);

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "operon-agents",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.3",
   "description": "Public SDK entrypoint for building agents.",
   "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -64,7 +67,7 @@
   ],
   "dependencies": {
     "zod": "^4.4.3",
-    "operon-agents-core": "0.1.0-alpha.1"
+    "operon-agents-core": "0.1.0-alpha.3"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "0.84.1"