@dxos/agent-runtime 0.0.0

package/dist/lib/neutral/chunk-EZKG2ZGG.mjs

@@ -0,0 +1,754 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/agent-service/agent-process.ts
+import * as Tool from "@effect/ai/Tool";
+import * as Toolkit from "@effect/ai/Toolkit";
+import * as Cause from "effect/Cause";
+import * as DateTime from "effect/DateTime";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Match from "effect/Match";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { AiService, OpaqueToolkit } from "@dxos/ai";
+import { AgentRequestBegin, AgentRequestEnd, AiSession, HarnessControl, SkillHooks, getOperationFromTool, makeToolExecutionService, makeToolResolverFromOperations } from "@dxos/assistant";
+import { Credential, Operation, Trace } from "@dxos/compute";
+import { Process } from "@dxos/compute";
+import { ProcessManager } from "@dxos/compute-runtime";
+import * as StorageService from "@dxos/compute/StorageService";
+import { Annotation, Database, Feed, Obj, Ref, Registry } from "@dxos/echo";
+import { EffectEx } from "@dxos/effect";
+import { DXN } from "@dxos/keys";
+import { log } from "@dxos/log";
+import { ContentBlock } from "@dxos/types";
+import { trim } from "@dxos/util";
+var __dxlog_file = "/Users/dmaretskyi/Code/dxos/dxos/packages/core/compute/agent-runtime/src/agent-service/agent-process.ts";
+var AGENT_PROCESS_KEY = "org.dxos.testing.process.agent";
+var AgentProcess = (options) => Process.make({
+  key: AGENT_PROCESS_KEY,
+  input: Schema.String,
+  output: Schema.Void,
+  services: [
+    Database.Service,
+    OpaqueToolkit.OpaqueToolkitProvider,
+    Operation.Service,
+    Registry.Service,
+    StorageService.StorageService,
+    ProcessManager.ProcessOperationInvoker.Service,
+    AiService.AiService,
+    // Needed in the fiber's context — `Header.byokLayer`'s per-request callback reads it.
+    Credential.CredentialsService
+  ],
+  rpcs: HarnessControl
+}, (ctx) => Effect.gen(function* () {
+  const feedDxn = Annotation.getDictionary(ctx.params.annotations, Process.TargetAnnotation).pipe(Option.getOrUndefined);
+  if (feedDxn == null) {
+    return yield* Effect.die(new Error("Agent executable requires spawn options.target set to a queue DXN."));
+  }
+  const feed = yield* Database.resolve(feedDxn, Feed.Feed).pipe(Effect.orDie);
+  const runtime3 = yield* Effect.runtime();
+  const session = yield* EffectEx.acquireReleaseResource(() => new AiSession.Session({
+    feed,
+    runtime: runtime3
+  }));
+  let inputQueue = [
+    ...yield* AgentEventsCell.get
+  ];
+  const storageService = yield* StorageService.StorageService;
+  const toolCallManager = new ToolCallManager(storageService);
+  yield* toolCallManager.load();
+  const clock2 = yield* Effect.clock;
+  const alarmManager = new AlarmManager({
+    storageService,
+    setAlarm: (timeout2) => ctx.setAlarm(timeout2),
+    now: () => clock2.unsafeCurrentTimeMillis()
+  });
+  yield* alarmManager.load();
+  yield* toolCallManager.reconcileWithInputQueue(inputQueue);
+  const strategy = Option.fromNullable(options.delegationStrategy);
+  let delegations = [
+    ...yield* DelegationsCell.get
+  ];
+  const requestModelLayer = AiService.model(options.model ? DXN.getName(options.model) : "com.anthropic.model.claude-opus-4-8.default", {
+    provider: options.provider
+  });
+  const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+  const runEndRequestHooks = Effect.gen(function* () {
+    yield* SkillHooks.runHooks({
+      skills: session.context.getSkills(),
+      phase: "end-request",
+      invoke: (operation, input) => Effect.gen(function* () {
+        const fiber = yield* operationInvoker.invokeFiber(operation, input, {
+          environment: {
+            conversation: Obj.getURI(feed)
+          },
+          traceMeta: {
+            conversation: Ref.make(feed)
+          }
+        });
+        const exit2 = yield* fiber.await;
+        if (Exit.isFailure(exit2)) {
+          yield* Effect.failCause(exit2.cause);
+        }
+      }).pipe(Effect.asVoid, Effect.orDie)
+    });
+  });
+  const maybeComplete = Effect.gen(function* () {
+    if (isAgentWorkPending({
+      inputQueue,
+      alarmManager,
+      delegations,
+      toolCallManager
+    })) {
+      return;
+    }
+    yield* runEndRequestHooks;
+    if (isAgentWorkPending({
+      inputQueue,
+      alarmManager,
+      delegations,
+      toolCallManager
+    })) {
+      log("agent work enqueued by end-request hook, continuing", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 133, S: this });
+      alarmManager.reconcile(true);
+      return;
+    }
+    log("agent work complete, succeeding", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 137, S: this });
+    ctx.succeed();
+  });
+  return {
+    // Control plane (§4.3): handlers run on the host process's server fiber, closing over the
+    // live `alarmManager`/`inputQueue` and persisting their durable effect inline.
+    rpcHandlers: yield* HarnessControl.toHandlersContext({
+      setAlarm: Effect.fn(function* ({ at, message }) {
+        yield* alarmManager.setWakeAt(DateTime.toEpochMillis(at), message);
+        alarmManager.reconcile(inputQueue.length > 0);
+      }),
+      enqueueMessage: Effect.fn(function* ({ content }) {
+        inputQueue.push({
+          _tag: "prompt",
+          content
+        });
+        yield* AgentEventsCell.set(inputQueue);
+        alarmManager.reconcile(true);
+      })
+    }),
+    onInput: Effect.fnUntraced(function* (prompt) {
+      log("agent onInput received", {
+        promptLength: prompt.length,
+        backlog: inputQueue.length
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 158, S: this });
+      inputQueue.push({
+        _tag: "prompt",
+        content: [
+          ContentBlock.Text.make({
+            text: prompt
+          })
+        ]
+      });
+      log("agent onInput persisting queue", {
+        depth: inputQueue.length
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 170, S: this });
+      yield* AgentEventsCell.set(inputQueue);
+      log("agent onInput persisted", {
+        depth: inputQueue.length
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 174, S: this });
+      alarmManager.reconcile(true);
+      log("agent onInput alarm scheduled", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 178, S: this });
+    }),
+    onAlarm: Effect.fnUntraced(function* () {
+      log("agent onAlarm fired", {
+        pending: inputQueue.length
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 181, S: this });
+      const fired = yield* alarmManager.takeFiredAlarm();
+      if (fired != null) {
+        log("agent onAlarm self-wake", {
+          firedAt: fired.firedAt
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 187, S: this });
+        inputQueue.push({
+          _tag: "alarm",
+          firedAt: fired.firedAt,
+          message: fired.message
+        });
+        yield* AgentEventsCell.set(inputQueue);
+      }
+      while (inputQueue.length > 0) {
+        const head = inputQueue[0];
+        if (head._tag === "tool_result" && toolCallManager.isReported(head.pid)) {
+          inputQueue.shift();
+          log.info("skip tool result that was reported synchronously", {
+            pid: head.pid
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 202, S: this });
+          continue;
+        }
+        break;
+      }
+      const item = inputQueue.shift();
+      if (!item) {
+        log("agent onAlarm empty queue", {}, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 211, S: this });
+        alarmManager.reconcile(false);
+        yield* AgentEventsCell.set(inputQueue);
+        yield* maybeComplete;
+        return;
+      }
+      log("agent onAlarm handling", {
+        tag: item._tag
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 217, S: this });
+      const prompt = Match.value(item).pipe(Match.tag("prompt", (item2) => [
+        ...item2.content
+      ]), Match.tag("tool_result", (item2) => item2.isError ? [
+        ContentBlock.Text.make({
+          text: toolErrorResponse(item2.pid, item2.result),
+          disposition: "synthetic"
+        })
+      ] : [
+        ContentBlock.Text.make({
+          text: toolResultResponse(item2.pid, item2.result),
+          disposition: "synthetic"
+        })
+      ]), Match.tag("alarm", (item2) => [
+        ContentBlock.Text.make({
+          text: wakeUpPrompt(item2.firedAt, item2.message),
+          disposition: "synthetic"
+        })
+      ]), Match.exhaustive);
+      log("begin request", {
+        prompt
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 238, S: this });
+      log("trace agent request begin", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 241, S: this });
+      yield* Trace.write(AgentRequestBegin, {});
+      yield* session.createRequest({
+        prompt,
+        // TODO(dmaretskyi): Polling currently broken, agent relies on completion notifications being delivered.
+        // toolkit: AsynchronousExectionToolkit,
+        // The alarm tools (set-alarm/get-current-date) now arrive as a bound blueprint whose
+        // operations reach this host's AlarmManager over HarnessService Tier B.
+        system: options.systemPrompt,
+        mcpServers: options.getMcpServers?.()
+      }).pipe(Effect.onExit((exit2) => Trace.write(AgentRequestEnd, {
+        status: Exit.isSuccess(exit2) ? "success" : Exit.isInterrupted(exit2) ? "interrupted" : "error",
+        error: Exit.isFailure(exit2) ? Cause.pretty(exit2.cause) : void 0
+      })));
+      log("end request", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 255, S: this });
+      yield* AgentEventsCell.set(inputQueue);
+      if (Option.isSome(strategy)) {
+        const activeIds = new Set(delegations.map((delegation) => delegation.id));
+        const pending = yield* strategy.value.reconcile(feed, activeIds);
+        for (const delegation of pending) {
+          const pid = yield* delegation.spawn;
+          delegations.push({
+            pid,
+            id: delegation.id
+          });
+          log("delegated work", {
+            pid,
+            id: delegation.id
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 268, S: this });
+        }
+        if (pending.length > 0) {
+          yield* DelegationsCell.set(delegations);
+        }
+      }
+      alarmManager.reconcile(inputQueue.length > 0);
+      yield* maybeComplete;
+    }, Effect.orDie, Effect.provide(Layer.mergeAll(makeToolResolverFromOperations(), ToolExecutionService({
+      toolCallManager,
+      feed,
+      enableBackgrounding: options.enableToolBackgrounding ?? false
+    }), AsynchronousExectionToolkitLayer, requestModelLayer).pipe(Layer.orDie))),
+    onChildEvent: Effect.fnUntraced(function* (event) {
+      log("childEvent", {
+        event
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 286, S: this });
+      if (event._tag === "exited") {
+        const delegation = delegations.find((delegation2) => delegation2.pid === event.pid);
+        if (delegation) {
+          delegations = delegations.filter((other) => other.pid !== event.pid);
+          yield* DelegationsCell.set(delegations);
+          const operationInvoker2 = yield* ProcessManager.ProcessOperationInvoker.Service;
+          const fiber = yield* operationInvoker2.attachFiber(event.pid).pipe(Effect.orDie);
+          const exit2 = yield* fiber.await;
+          if (Option.isSome(strategy)) {
+            yield* strategy.value.onComplete(feed, delegation.id, exit2);
+          }
+          log("delegated work completed", {
+            pid: event.pid,
+            id: delegation.id,
+            success: Exit.isSuccess(exit2)
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 303, S: this });
+          yield* maybeComplete;
+        } else if (toolCallManager.isToolCall(event.pid)) {
+          const operationInvoker2 = yield* ProcessManager.ProcessOperationInvoker.Service;
+          const attachExit = yield* operationInvoker2.attachFiber(event.pid).pipe(Effect.exit);
+          if (Exit.isFailure(attachExit)) {
+            if (toolCallManager.isToolCall(event.pid) || inputQueue.some((item) => item._tag === "tool_result" && item.pid === event.pid) || toolCallManager.isReported(event.pid)) {
+              log.verbose("childEvent skipped (process gone, result already handled)", {
+                pid: event.pid
+              }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 316, S: this });
+              return;
+            }
+            return yield* Effect.failCause(attachExit.cause).pipe(Effect.orDie);
+          }
+          const fiber = attachExit.value;
+          const result = yield* fiber.await.pipe(Effect.orDie).pipe(Effect.map(Exit.match({
+            onSuccess: (value2) => ({
+              _tag: "tool_result",
+              pid: event.pid,
+              result: value2,
+              isError: false
+            }),
+            onFailure: (cause) => ({
+              _tag: "tool_result",
+              pid: event.pid,
+              result: Cause.pretty(cause),
+              isError: true
+            })
+          })));
+          inputQueue.push(result);
+          log("agent onChildEvent persisted tool result", {
+            depth: inputQueue.length,
+            childPid: event.pid
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 339, S: this });
+          yield* AgentEventsCell.set(inputQueue);
+          alarmManager.reconcile(true);
+          log("agent onChildEvent alarm scheduled", {
+            depth: inputQueue.length
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 345, S: this });
+        } else {
+          log.verbose("childEvent ignored non-tool call and not a delegation", {
+            pid: event.pid
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 349, S: this });
+        }
+      }
+    })
+  };
+}));
+var AgentEvent = Schema.Union(Schema.TaggedStruct("prompt", {
+  content: Schema.Array(ContentBlock.Any)
+}), Schema.TaggedStruct("tool_result", {
+  pid: Process.ID,
+  result: Schema.Unknown,
+  isError: Schema.Boolean
+}), Schema.TaggedStruct("alarm", {
+  firedAt: Schema.Number,
+  // Optional reminder carried from the self-wake; surfaced to the agent when the alarm fires.
+  message: Schema.NullOr(Schema.String)
+}));
+var AgentEventsCell = StorageService.cell(Schema.parseJson(Schema.Array(AgentEvent).pipe(Schema.mutable)), "inputQueue").pipe(StorageService.withDefault(() => []));
+var Delegation = Schema.Struct({
+  pid: Process.ID,
+  id: Schema.String
+}).pipe(Schema.mutable);
+var DelegationsCell = StorageService.cell(Schema.parseJson(Schema.Array(Delegation).pipe(Schema.mutable)), "delegations").pipe(StorageService.withDefault(() => []));
+var ToolCallState = Schema.Struct({
+  activeCalls: Schema.Array(Schema.Struct({
+    pid: Process.ID,
+    // Whether the result was reported to the agent.
+    reported: Schema.Boolean
+  }).pipe(Schema.mutable)).pipe(Schema.mutable)
+});
+var ToolCallStateCell = StorageService.cell(Schema.parseJson(ToolCallState.pipe(Schema.mutable)), "toolCallState").pipe(StorageService.withDefault(() => ({
+  activeCalls: []
+})));
+var ToolCallManager = class {
+  #storageService;
+  #state = {
+    activeCalls: []
+  };
+  constructor(storageService) {
+    this.#storageService = storageService;
+  }
+  load() {
+    return Effect.gen(this, function* () {
+      this.#state = yield* ToolCallStateCell.get;
+    }).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+  }
+  beginCall(pid) {
+    return Effect.gen(this, function* () {
+      this.#state.activeCalls.push({
+        pid,
+        reported: false
+      });
+      yield* ToolCallStateCell.set(this.#state);
+    }).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+  }
+  markAsReported(pid) {
+    return Effect.gen(this, function* () {
+      const call = this.#state.activeCalls.find((call2) => call2.pid === pid);
+      if (!call) {
+        return;
+      }
+      call.reported = true;
+      yield* ToolCallStateCell.set(this.#state);
+    }).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+  }
+  isToolCall(pid) {
+    return this.#state.activeCalls.some((call) => call.pid === pid);
+  }
+  isReported(pid) {
+    return this.#state.activeCalls.some((call) => call.pid === pid && call.reported);
+  }
+  /** True while a tool-call result has not yet been delivered back to the agent turn. */
+  hasPendingToolResults() {
+    return this.#state.activeCalls.some((call) => !call.reported);
+  }
+  /**
+  * Clears reported flags for tool calls that still have a pending queue entry.
+  * After reload the in-flight createRequest is gone, so those results must be redelivered via onAlarm.
+  */
+  reconcileWithInputQueue(queue) {
+    return Effect.gen(this, function* () {
+      let changed = false;
+      for (const item of queue) {
+        if (item._tag !== "tool_result") {
+          continue;
+        }
+        const call = this.#state.activeCalls.find((entry) => entry.pid === item.pid);
+        if (call?.reported) {
+          call.reported = false;
+          changed = true;
+          log("reconcile queued tool result", {
+            pid: item.pid
+          }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 443, S: this });
+        }
+      }
+      if (changed) {
+        yield* ToolCallStateCell.set(this.#state);
+      }
+    }).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+  }
+};
+var isAgentWorkPending = ({ inputQueue, alarmManager, delegations, toolCallManager }) => inputQueue.length > 0 || alarmManager.wakeAt != null || delegations.length > 0 || toolCallManager.hasPendingToolResults();
+var AgentAlarmCell = StorageService.cell(Schema.parseJson(Schema.NullOr(Schema.Struct({
+  wakeAt: Schema.Number,
+  message: Schema.NullOr(Schema.String)
+}))), "agentAlarm").pipe(StorageService.withDefault(() => null));
+var computeAlarmDelay = ({ hasPendingWork, wakeAt, now }) => {
+  if (hasPendingWork) {
+    return 0;
+  }
+  if (wakeAt != null) {
+    return Math.max(0, wakeAt - now);
+  }
+  return null;
+};
+var AlarmManager = class {
+  #storageService;
+  #setAlarm;
+  #now;
+  #wakeAt = null;
+  #message = null;
+  constructor({ storageService, setAlarm, now = () => Date.now() }) {
+    this.#storageService = storageService;
+    this.#setAlarm = setAlarm;
+    this.#now = now;
+  }
+  /** Currently scheduled self-wake timestamp (ms), or `null` when none is set. */
+  get wakeAt() {
+    return this.#wakeAt;
+  }
+  /** Reminder message delivered when the current self-wake fires, or `null` when none is set. */
+  get message() {
+    return this.#message;
+  }
+  now() {
+    return this.#now();
+  }
+  /** Restores the persisted alarm state. */
+  load() {
+    return Effect.gen(this, function* () {
+      const persisted = yield* AgentAlarmCell.get;
+      this.#wakeAt = persisted?.wakeAt ?? null;
+      this.#message = persisted?.message ?? null;
+    }).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+  }
+  /** Records a new self-wake target (with an optional reminder message) and persists it. */
+  setWakeAt(wakeAt, message = null) {
+    return Effect.gen(this, function* () {
+      this.#wakeAt = wakeAt;
+      this.#message = message;
+      yield* AgentAlarmCell.set({
+        wakeAt,
+        message
+      });
+    }).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+  }
+  /**
+  * Clears the self-wake alarm if it is due, returning the timestamp it was scheduled for and the
+  * reminder message it carried (or `null` if no alarm was due).
+  */
+  takeFiredAlarm() {
+    return Effect.gen(this, function* () {
+      if (this.#wakeAt == null || this.#now() < this.#wakeAt) {
+        return null;
+      }
+      const firedAt = this.#wakeAt;
+      const message = this.#message;
+      this.#wakeAt = null;
+      this.#message = null;
+      yield* AgentAlarmCell.set(null);
+      return {
+        firedAt,
+        message
+      };
+    }).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
+  }
+  /**
+  * Reconciles the process alarm timer with pending work and the tracked self-wake, scheduling the
+  * earliest of the two. Does nothing when there is neither pending work nor a self-wake.
+  */
+  reconcile(hasPendingWork) {
+    const delay = computeAlarmDelay({
+      hasPendingWork,
+      wakeAt: this.#wakeAt,
+      now: this.#now()
+    });
+    if (delay != null) {
+      this.#setAlarm(delay);
+    }
+  }
+};
+var wakeUpPrompt = (firedAt, message) => message != null ? trim`
+      Your scheduled alarm fired (it was set for ${new Date(firedAt).toISOString()}).
+      ${message}
+    ` : trim`
+      Your scheduled alarm fired (it was set for ${new Date(firedAt).toISOString()}).
+      Continue with whatever you intended to do when you scheduled this wake-up.
+    `;
+var ToolExecutionService = ({ enableBackgrounding, backgroundThreshold = Duration.seconds(1), toolCallManager, feed }) => Layer.unwrapEffect(Effect.gen(function* () {
+  const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+  return makeToolExecutionService({
+    invoke: (tool, input) => Effect.gen(function* () {
+      const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
+      log("invoking operation", {
+        operationDef,
+        input
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 567, S: this });
+      const fiber = yield* operationInvoker.invokeFiber(operationDef, input, {
+        environment: {
+          conversation: Obj.getURI(feed)
+        },
+        traceMeta: {
+          conversation: Ref.make(feed)
+        }
+      });
+      yield* toolCallManager.beginCall(fiber.pid);
+      log("invoked operation", {
+        operationDef,
+        input,
+        fiber
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 580, S: this });
+      const awaitWithReport = fiber.await.pipe(Effect.tap(() => toolCallManager.markAsReported(fiber.pid)));
+      const result = enableBackgrounding ? yield* awaitWithReport.pipe(Effect.timeout(backgroundThreshold), Effect.catchTag("TimeoutException", () => Effect.succeed(Exit.succeed(toolIsRunningInBackgroundResponse(fiber.pid))))) : yield* awaitWithReport;
+      log("result", {
+        result
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 587, S: this });
+      return yield* result;
+    })
+  });
+}));
+var AsynchronousExectionToolkit = class extends Toolkit.make(Tool.make("poll-tools", {
+  description: trim`
+      Poll tool calls running in the background.
+      Set wait to true to wait for the tool call to complete before returning.
+      Only set wait to true if you dont have other tasks to perform in parallel.
+      Set an appropriate timeout to avoid waiting forever.
+      You will also be notified about the job completion separatelly, so you do not always need to inspect the job if you dont need the result right now.
+    `,
+  parameters: {
+    ids: Schema.Array(Schema.String).annotations({
+      description: "The IDs of the jobs to inspect."
+    }),
+    wait: Schema.optional(Schema.Boolean).annotations({
+      description: "Whether to wait for the tool call to complete before returning.",
+      default: false
+    }),
+    timeout: Schema.optional(Schema.Number).annotations({
+      description: "Maximum time to wait for the job to complete. If the job does not complete within the timeout, the current state is returned.",
+      default: 1e4
+    })
+  }
+})) {
+};
+var AsynchronousExectionToolkitLayer = AsynchronousExectionToolkit.toLayer(Effect.gen(function* () {
+  const invoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+  return {
+    "poll-tools": ({ ids, wait, timeout: timeout2 = 1e4 }) => Effect.gen(function* () {
+      return yield* Effect.forEach(ids, (pid) => invoker.attachFiber(Process.ID.make(pid)).pipe(Effect.flatMap((_) => _.await), Effect.timeout(Duration.millis(timeout2)), Effect.flatMap(Exit.match({
+        onSuccess: (value2) => Effect.succeed(toolResultResponse(pid, value2)),
+        onFailure: (cause) => Effect.succeed(toolErrorResponse(pid, Cause.pretty(cause)))
+      })), Effect.catchTag("ProcessNotFoundError", () => Effect.succeed(`Process not found: ${pid}`)), Effect.catchTag("TimeoutException", () => Effect.succeed(`Process still running: ${pid}`))));
+    })
+  };
+}));
+var toolIsRunningInBackgroundResponse = (pid) => `Tool is running in the background (id=${pid}); wait for the completion notification to get the result.`;
+var toolResultResponse = (pid, value2) => `<result pid=${pid}>${JSON.stringify(value2)}</result>`;
+var toolErrorResponse = (pid, cause) => `<error pid=${pid}>${cause}</error>`;
+
+// src/agent-service/AgentService.ts
+var AgentService_exports = {};
+__export(AgentService_exports, {
+  createSession: () => createSession,
+  layer: () => layer
+});
+import * as Cause2 from "effect/Cause";
+import * as Effect2 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { AiContext } from "@dxos/assistant";
+import { Process as Process2, Skill } from "@dxos/compute";
+import { ProcessManager as ProcessManager2 } from "@dxos/compute-runtime";
+import { AgentService, getSession } from "@dxos/compute/AgentService";
+import { Annotation as Annotation2, Database as Database2, Feed as Feed2, Obj as Obj2, Ref as Ref2 } from "@dxos/echo";
+import { EffectEx as EffectEx2 } from "@dxos/effect";
+import { EID } from "@dxos/keys";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file2 = "/Users/dmaretskyi/Code/dxos/dxos/packages/core/compute/agent-runtime/src/agent-service/AgentService.ts";
+var isTerminalProcess = (state) => state === Process2.State.SUCCEEDED || state === Process2.State.FAILED || state === Process2.State.TERMINATED;
+var createSession = Effect2.fn("createSession")(function* (opts) {
+  const skills = yield* Effect2.forEach(opts?.skills ?? [], (skill) => Skill.upsert(Skill.getKey(skill)).pipe(Effect2.map(Ref2.make)));
+  const feed = yield* Database2.add(Feed2.make());
+  const runtime3 = yield* Effect2.runtime();
+  const binder = yield* EffectEx2.acquireReleaseResource(() => new AiContext.Binder({
+    feed,
+    runtime: runtime3
+  }));
+  yield* Effect2.promise(() => binder.bind({
+    skills,
+    objects: opts?.context ?? []
+  }));
+  return yield* getSession(feed, {
+    model: opts?.model,
+    provider: opts?.provider
+  });
+}, Effect2.scoped);
+var layer = (opts) => Layer2.effect(AgentService, Effect2.gen(function* () {
+  const processManager = yield* ProcessManager2.Service;
+  const sessionCache = /* @__PURE__ */ new Map();
+  const makeExecutable = (model, provider) => AgentProcess({
+    systemPrompt: opts?.systemPrompt,
+    model: model ?? opts?.model,
+    provider: provider ?? opts?.provider,
+    getMcpServers: opts?.getMcpServers,
+    enableToolBackgrounding: opts?.enableToolBackgrounding,
+    delegationStrategy: opts?.delegationStrategy
+  });
+  const hydrateAgents = Effect2.fnUntraced(function* () {
+    sessionCache.clear();
+    const executable = makeExecutable();
+    const agents = yield* processManager.list({
+      key: AGENT_PROCESS_KEY
+    });
+    log2("agent hydrate", {
+      count: agents.length
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 56, S: this });
+    for (const agent of agents) {
+      yield* agent.hydrate(executable).pipe(Effect2.catchAllCause((cause) => Effect2.sync(() => log2.warn("agent hydrate skipped", {
+        pid: agent.pid,
+        cause: Cause2.pretty(cause)
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 60, S: this }))));
+    }
+  });
+  const service = {
+    getSession: (feed, options) => Effect2.gen(function* () {
+      const model = options?.model ?? opts?.model;
+      const provider = options?.provider ?? opts?.provider;
+      const cached = sessionCache.get(feed.id);
+      if (cached) {
+        if (cached.model === model && cached.provider === provider && !isTerminalProcess(cached.handle.status.state)) {
+          return cached.session;
+        }
+        if (!isTerminalProcess(cached.handle.status.state)) {
+          yield* cached.handle.terminate();
+        }
+        sessionCache.delete(feed.id);
+      }
+      const target = Obj2.getURI(feed);
+      const parsedEchoUri = EID.tryParse(target);
+      const spaceId = parsedEchoUri ? EID.getSpaceId(parsedEchoUri) : void 0;
+      const executable = makeExecutable(model, provider);
+      const processes = yield* processManager.list({
+        target,
+        key: executable.key
+      });
+      const activeProcess = processes.find((process) => !isTerminalProcess(process.status.state));
+      let handle;
+      if (activeProcess) {
+        yield* activeProcess.hydrate(executable);
+        handle = activeProcess;
+      } else {
+        handle = yield* processManager.spawn(executable, {
+          name: "Agent",
+          target,
+          // Stamp the host marker so the harness control surface is discoverable by annotation
+          // lookup (set once at spawn, immutable — the identity plane).
+          annotations: Annotation2.buildDictionary((dictionary) => {
+            Annotation2.setDictionary(dictionary, Process2.HarnessHostAnnotation, true);
+          }),
+          environment: {
+            ...spaceId !== void 0 ? {
+              space: spaceId
+            } : {},
+            conversation: target
+          },
+          traceMeta: {
+            conversation: Ref2.make(feed)
+          }
+        });
+      }
+      const releaseSession = () => {
+        sessionCache.delete(feed.id);
+      };
+      const session = makeSession(handle, feed, releaseSession);
+      sessionCache.set(feed.id, {
+        model,
+        provider,
+        handle,
+        session
+      });
+      return session;
+    }),
+    hydrate: hydrateAgents
+  };
+  return service;
+}));
+var makeSession = (process, feed, releaseSession) => ({
+  feed,
+  getContext: () => Effect2.gen(function* () {
+    const runtime3 = yield* Effect2.runtime();
+    const binder = yield* EffectEx2.acquireReleaseResource(() => new AiContext.Binder({
+      feed,
+      runtime: runtime3
+    }));
+    return binder.getObjects().map((object) => Ref2.make(object));
+  }).pipe(Effect2.scoped),
+  addContext: (context) => Effect2.gen(function* () {
+    const runtime3 = yield* Effect2.runtime();
+    const binder = yield* EffectEx2.acquireReleaseResource(() => new AiContext.Binder({
+      feed,
+      runtime: runtime3
+    }));
+    yield* Effect2.promise(() => binder.bind({
+      skills: [],
+      objects: context
+    }));
+  }).pipe(Effect2.scoped),
+  submitPrompt: (prompt) => process.submitInput(prompt),
+  // Settle when the turn's reply is complete; do NOT block on background sub-agents
+  // (a supervisor delegates work that runs after the turn and reports back out of band).
+  waitForCompletion: () => process.runUntilSettled(),
+  terminate: () => process.terminate().pipe(Effect2.tap(() => Effect2.sync(releaseSession))),
+  subscribeEphemeral: () => process.subscribeEphemeral()
+});
+
+export {
+  __export,
+  AGENT_PROCESS_KEY,
+  AgentService_exports
+};
+//# sourceMappingURL=chunk-EZKG2ZGG.mjs.map