@cuylabs/agent-physical-capx 5.0.2

package/dist/chunk-MYO63CWO.js

@@ -0,0 +1,869 @@
+// src/session.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { Tool } from "@cuylabs/agent-core/tool";
+import {
+  createPhysicalSessionTools
+} from "@cuylabs/agent-physical";
+import { z } from "zod";
+
+// src/live-runtime/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/live-runtime/http-client.ts
+import { setTimeout as sleep } from "timers/promises";
+
+// src/live-runtime/utils.ts
+import { randomUUID } from "crypto";
+var DEFAULT_RUNTIME_REQUEST_TIMEOUT_MS = 1e6;
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+function resolveOutputDir(options, fallback) {
+  return options.outputDir ?? fallback;
+}
+function withoutUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0)
+  );
+}
+function failedTrace(request, reason, metadata = {}) {
+  const now = Date.now();
+  return {
+    id: `capx-live-${randomUUID()}`,
+    startedAt: now,
+    completedAt: now,
+    request,
+    stderr: reason,
+    outcome: {
+      success: false,
+      reason
+    },
+    metadata
+  };
+}
+
+// src/live-runtime/http-client.ts
+var CapxRuntimeHttpClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  #baseUrl;
+  get baseUrl() {
+    return this.#baseUrl;
+  }
+  get stdoutTail() {
+    return "";
+  }
+  get stderrTail() {
+    return "";
+  }
+  get ready() {
+    return this.#baseUrl !== void 0;
+  }
+  async ensureStarted() {
+    if (this.#baseUrl) {
+      return;
+    }
+    this.#baseUrl = normalizeBaseUrl(this.options.runtimeServerUrl);
+    await this.#waitForHealth(
+      this.options.runtimeServerStartupTimeoutMs ?? 5e3
+    );
+  }
+  async request(method, route, body, timeoutMs = this.options.runtimeServerRequestTimeoutMs ?? this.options.policyExecutionTimeoutMs ?? DEFAULT_RUNTIME_REQUEST_TIMEOUT_MS) {
+    const baseUrl = this.requireBaseUrl();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    timer.unref();
+    try {
+      const response = await fetch(`${baseUrl}${route}`, {
+        method,
+        headers: body ? {
+          "content-type": "application/json"
+        } : void 0,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(
+          `capx-agent-runtime ${method} ${route} failed with ${response.status}: ${text}`
+        );
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async stop(sessionId) {
+    if (!sessionId || !this.#baseUrl) {
+      return;
+    }
+    try {
+      await this.request("POST", `/sessions/${sessionId}/stop`, {}, 5e3);
+    } catch {
+    }
+  }
+  requireBaseUrl() {
+    if (!this.#baseUrl) {
+      throw new Error("capx-agent-runtime base URL is not configured.");
+    }
+    return this.#baseUrl;
+  }
+  async #waitForHealth(timeoutMs) {
+    const started = Date.now();
+    let lastError;
+    while (Date.now() - started < timeoutMs) {
+      try {
+        await this.request("GET", "/health", void 0, 1e3);
+        return;
+      } catch (error) {
+        lastError = error;
+        await sleep(250);
+      }
+    }
+    throw new Error(
+      `Timed out waiting for capx-agent-runtime health after ${timeoutMs}ms. ${String(
+        lastError
+      )}`
+    );
+  }
+};
+
+// src/live-runtime/mappers.ts
+function mapExecutionResult(result) {
+  if (!result) {
+    return null;
+  }
+  return {
+    success: result.success ?? false,
+    reward: result.reward ?? void 0,
+    terminated: result.terminated,
+    truncated: result.truncated,
+    sandboxRc: result.sandboxRc ?? result.sandbox_rc,
+    stdout: result.stdout,
+    stderr: result.stderr,
+    taskCompleted: result.taskCompleted ?? result.task_completed,
+    codePath: result.codePath ?? result.code_path,
+    elapsedMs: result.elapsedMs ?? result.elapsed_ms,
+    error: result.error,
+    diagnostics: result.diagnostics
+  };
+}
+function mapObservation(observation) {
+  if (!observation) {
+    return {};
+  }
+  return {
+    trial: observation.trial,
+    taskPrompt: observation.taskPrompt ?? observation.task_prompt ?? void 0,
+    multiTurnPrompt: observation.multiTurnPrompt ?? observation.multi_turn_prompt ?? void 0,
+    fullPrompt: observation.fullPrompt ?? observation.full_prompt,
+    resetInfo: observation.resetInfo ?? observation.reset_info,
+    lastStep: mapExecutionResult(observation.lastStep ?? observation.last_step),
+    runtimeConfig: observation.runtimeConfig ?? observation.runtime_config ?? void 0,
+    codeContext: mapCodeContext(
+      observation.codeContext ?? observation.code_context
+    )
+  };
+}
+function mapCodeContext(context) {
+  if (!context) {
+    return void 0;
+  }
+  return {
+    policyLanguage: context.policyLanguage ?? context.policy_language,
+    executionModel: context.executionModel ?? context.execution_model,
+    submitVia: context.submitVia ?? context.submit_via,
+    affordances: context.affordances?.map(mapCodeAffordance),
+    skillLibrarySummary: context.skillLibrarySummary ?? context.skill_library_summary,
+    skillLibraryDocs: context.skillLibraryDocs ?? context.skill_library_docs
+  };
+}
+function mapCodeAffordance(affordance) {
+  return {
+    name: affordance.name,
+    description: affordance.description,
+    inputSchema: affordance.inputSchema ?? affordance.input_schema,
+    source: affordance.source,
+    symbol: affordance.symbol,
+    tags: affordance.tags,
+    metadata: affordance.metadata
+  };
+}
+function mapFrame(frame) {
+  if (!frame) {
+    return {};
+  }
+  return {
+    source: frame.source,
+    mimeType: frame.mimeType ?? frame.mime_type,
+    encoding: frame.encoding,
+    data: frame.data,
+    dataUrl: frame.dataUrl ?? frame.data_url,
+    width: frame.width ?? void 0,
+    height: frame.height ?? void 0,
+    timestamp: frame.timestamp
+  };
+}
+function mapRuntimeArtifact(artifact, baseUrl) {
+  const relativePath = artifact.path ?? "artifact";
+  const relativeUrl = artifact.url ?? "";
+  return {
+    id: `capx-runtime:${relativePath}`,
+    kind: mapArtifactKind(artifact.kind),
+    uri: relativeUrl.startsWith("http") ? relativeUrl : `${baseUrl}${relativeUrl}`,
+    label: relativePath,
+    metadata: {
+      capx: {
+        path: relativePath,
+        sizeBytes: artifact.sizeBytes ?? artifact.size_bytes,
+        modifiedTime: artifact.modifiedTime ?? artifact.modified_time,
+        kind: artifact.kind
+      }
+    }
+  };
+}
+function mapSkillExtraction(response) {
+  return {
+    path: response.path,
+    taskName: response.taskName ?? response.task_name,
+    newSkills: response.newSkills ?? response.new_skills ?? [],
+    total: response.total
+  };
+}
+function mapSkillInjection(response) {
+  return {
+    path: response.path,
+    injected: response.injected ?? 0,
+    promotedSkills: response.promotedSkills ?? response.promoted_skills ?? []
+  };
+}
+function mapArtifactKind(kind) {
+  if (kind === "image" || kind === "video" || kind === "json") {
+    return kind;
+  }
+  if (kind === "text") {
+    return "log";
+  }
+  return "other";
+}
+
+// src/live-runtime/index.ts
+var DEFAULT_OUTPUT_DIR = "outputs/agent-physical-capx-live";
+var CapxLiveRuntime = class {
+  constructor(options, id = `capx-live-${randomUUID2()}`) {
+    this.options = options;
+    this.id = id;
+    this.outputDir = resolveOutputDir(options, DEFAULT_OUTPUT_DIR);
+    this.#client = new CapxRuntimeHttpClient(options);
+  }
+  id;
+  outputDir;
+  #client;
+  #sessionId;
+  #lastObservation;
+  get stdoutTail() {
+    return this.#client.stdoutTail;
+  }
+  get stderrTail() {
+    return this.#client.stderrTail;
+  }
+  get running() {
+    return this.#sessionId !== void 0 && this.#client.ready;
+  }
+  async start() {
+    if (this.#sessionId && this.#lastObservation) {
+      return this.#lastObservation;
+    }
+    try {
+      await this.#client.ensureStarted();
+      const response = await this.#client.request(
+        "POST",
+        "/sessions",
+        this.#sessionOptionsPayload()
+      );
+      const sessionId = response.sessionId ?? response.session_id;
+      if (!sessionId) {
+        throw new Error("capx-agent-runtime did not return a session id.");
+      }
+      this.#sessionId = sessionId;
+      this.#lastObservation = mapObservation(response.observation);
+      return this.#lastObservation;
+    } catch (error) {
+      await this.stop();
+      throw error;
+    }
+  }
+  async observe() {
+    await this.start();
+    const response = await this.#client.request(
+      "GET",
+      `/sessions/${this.#requireSessionId()}/observe`,
+      void 0,
+      this.options.runtimeServerRequestTimeoutMs
+    );
+    const observation = mapObservation(response.observation);
+    this.#lastObservation = observation;
+    return observation;
+  }
+  async renderFrame(camera = "main") {
+    await this.start();
+    const response = await this.#client.request(
+      "GET",
+      `/sessions/${this.#requireSessionId()}/render?camera=${encodeURIComponent(camera)}`,
+      void 0,
+      this.options.runtimeServerRequestTimeoutMs
+    );
+    return mapFrame(response);
+  }
+  async turnHistory() {
+    await this.start();
+    const response = await this.#client.request(
+      "GET",
+      `/sessions/${this.#requireSessionId()}/turns`,
+      void 0,
+      this.options.runtimeServerRequestTimeoutMs
+    );
+    return response.turns ?? [];
+  }
+  async skillLibrary() {
+    await this.start();
+    return await this.#client.request(
+      "GET",
+      `/sessions/${this.#requireSessionId()}/skill-library`,
+      void 0,
+      this.options.runtimeServerRequestTimeoutMs
+    );
+  }
+  async extractSkills(options = {}) {
+    await this.start();
+    const response = await this.#client.request(
+      "POST",
+      `/sessions/${this.#requireSessionId()}/skill-library/extract`,
+      withoutUndefined({
+        code: options.code,
+        task_name: options.taskName
+      }),
+      this.options.runtimeServerRequestTimeoutMs
+    );
+    return mapSkillExtraction(response);
+  }
+  async injectSkillLibrary(minOccurrences = 2) {
+    await this.start();
+    const response = await this.#client.request(
+      "POST",
+      `/sessions/${this.#requireSessionId()}/skill-library/inject`,
+      {
+        min_occurrences: minOccurrences
+      },
+      this.options.runtimeServerRequestTimeoutMs
+    );
+    return mapSkillInjection(response);
+  }
+  async listArtifacts(limit = 50) {
+    await this.start();
+    const response = await this.#client.request(
+      "GET",
+      `/sessions/${this.#requireSessionId()}/artifacts`,
+      void 0,
+      this.options.runtimeServerRequestTimeoutMs
+    );
+    const artifacts = response.artifacts ?? [];
+    const baseUrl = this.#client.requireBaseUrl();
+    return artifacts.slice(0, limit).map((artifact) => mapRuntimeArtifact(artifact, baseUrl));
+  }
+  async reset(trial) {
+    await this.start();
+    const response = await this.#client.request(
+      "POST",
+      `/sessions/${this.#requireSessionId()}/reset`,
+      withoutUndefined({ trial }),
+      this.options.runtimeServerRequestTimeoutMs
+    );
+    const observation = mapObservation(response.observation);
+    this.#lastObservation = observation;
+    return observation;
+  }
+  async execute(request) {
+    const preflightFailure = this.#validateExecutionRequest(request);
+    if (preflightFailure) {
+      return preflightFailure;
+    }
+    if (request.dryRun) {
+      return dryRunTrace(request);
+    }
+    await this.start();
+    const startedAt = Date.now();
+    const traceId = `capx-live-${randomUUID2()}`;
+    const response = await this.#client.request(
+      "POST",
+      `/sessions/${this.#requireSessionId()}/execute-code`,
+      { code: request.code },
+      request.timeoutMs ?? this.options.policyExecutionTimeoutMs ?? this.options.runtimeServerRequestTimeoutMs
+    );
+    const result = mapExecutionResult(response.result) ?? {
+      success: false,
+      stderr: "capx-agent-runtime returned no execution result."
+    };
+    this.#lastObservation = {
+      ...this.#lastObservation,
+      lastStep: result
+    };
+    return {
+      id: traceId,
+      startedAt,
+      completedAt: Date.now(),
+      request,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      artifacts: await this.#listExecutionArtifacts(),
+      outcome: {
+        success: result.success,
+        reward: result.reward,
+        taskCompleted: result.taskCompleted ?? void 0,
+        terminated: result.terminated,
+        truncated: result.truncated,
+        metadata: {
+          sandboxRc: result.sandboxRc,
+          elapsedMs: result.elapsedMs,
+          codePath: result.codePath,
+          diagnostics: result.diagnostics,
+          runtimeServer: "capx-agent-runtime"
+        }
+      },
+      metadata: {
+        capx: {
+          executionMode: "live-runtime",
+          runtimeServer: "capx-agent-runtime",
+          runtimeServerUrl: this.#client.baseUrl,
+          outputDir: this.outputDir
+        }
+      }
+    };
+  }
+  async stop() {
+    const sessionId = this.#sessionId;
+    this.#sessionId = void 0;
+    this.#lastObservation = void 0;
+    await this.#client.stop(sessionId);
+  }
+  #sessionOptionsPayload() {
+    return withoutUndefined({
+      trial: this.options.policyExecutionTrial,
+      output_dir: this.options.outputDir,
+      record_video: this.options.policyExecutionRecordVideo,
+      start_api_servers: this.options.policyExecutionStartApiServers,
+      skill_library_path: this.options.skillLibraryPath
+    });
+  }
+  #validateExecutionRequest(request) {
+    if (request.language && request.language !== "python") {
+      return failedTrace(
+        request,
+        `CaP-X live runtime only supports Python, got ${request.language}.`
+      );
+    }
+    if (this.options.physicalMode === "hardware" && !this.options.allowHardwarePolicyExecution) {
+      return failedTrace(
+        request,
+        "Hardware policy execution is blocked. Set allowHardwarePolicyExecution to opt in.",
+        { physicalMode: this.options.physicalMode }
+      );
+    }
+    return void 0;
+  }
+  async #listExecutionArtifacts() {
+    try {
+      return await this.listArtifacts(50);
+    } catch {
+      return [];
+    }
+  }
+  #requireSessionId() {
+    if (!this.#sessionId) {
+      throw new Error("capx-agent-runtime session is not started.");
+    }
+    return this.#sessionId;
+  }
+};
+function dryRunTrace(request) {
+  const now = Date.now();
+  return {
+    id: `capx-live-${randomUUID2()}`,
+    startedAt: now,
+    completedAt: now,
+    request,
+    stdout: "Dry run accepted; code was not executed.",
+    outcome: {
+      success: true,
+      metadata: {
+        dryRun: true
+      }
+    },
+    metadata: {
+      capx: {
+        executionMode: "live-runtime",
+        runtimeServer: "capx-agent-runtime"
+      }
+    }
+  };
+}
+
+// src/session.ts
+var RUNTIME_DEFAULT_TASK_ID = "capx-agent-runtime-defaults";
+var RUNTIME_DEFAULT_TASK_DESCRIPTION = "CaP-X config managed by capx-agent-runtime";
+var CapxSession = class {
+  id;
+  options;
+  capabilities;
+  executeCode;
+  #status = "idle";
+  #startedAt;
+  #updatedAt = Date.now();
+  #message;
+  #liveRuntime;
+  constructor(options, id = `capx-${randomUUID3()}`) {
+    this.options = {
+      mode: "runtime",
+      physicalMode: "unknown",
+      policyExecutionMode: "live-runtime",
+      ...options
+    };
+    this.id = id;
+    if (this.options.enablePolicyCodeExecution) {
+      this.capabilities = [
+        {
+          name: "capx_live_runtime_policy_code",
+          description: "Execute supplied Python policy code through capx-agent-runtime in a live CaP-X environment.",
+          safety: {
+            riskLevel: "dangerous",
+            requiresApproval: true,
+            requiresHumanPresence: this.options.physicalMode === "hardware",
+            allowedModes: this.options.physicalMode === "hardware" ? ["hardware"] : ["simulation", "hybrid", "unknown"]
+          },
+          metadata: {
+            capx: {
+              executionMode: "live-runtime",
+              activeProcessInjection: false,
+              activeRuntimeSession: true,
+              runtimeServer: "capx-agent-runtime",
+              loopOwner: "agent-core"
+            }
+          }
+        }
+      ];
+      this.executeCode = (request) => this.#executePolicyCode(request);
+    }
+  }
+  #runtime() {
+    if (!this.#liveRuntime) {
+      this.#liveRuntime = new CapxLiveRuntime(
+        this.options,
+        `${this.id}-runtime`
+      );
+    }
+    return this.#liveRuntime;
+  }
+  async #ensureLiveRuntime() {
+    const runtime = this.#runtime();
+    await runtime.start();
+    return runtime;
+  }
+  async #executePolicyCode(request) {
+    this.#status = "running";
+    this.#updatedAt = Date.now();
+    try {
+      return await this.#runtime().execute(request);
+    } finally {
+      this.#status = "ready";
+      this.#updatedAt = Date.now();
+    }
+  }
+  getState() {
+    return {
+      sessionId: this.id,
+      status: this.#status,
+      task: this.options.task ?? {
+        id: RUNTIME_DEFAULT_TASK_ID,
+        description: RUNTIME_DEFAULT_TASK_DESCRIPTION,
+        environment: "capx",
+        mode: this.options.physicalMode
+      },
+      mode: this.options.physicalMode,
+      startedAt: this.#startedAt,
+      updatedAt: this.#updatedAt,
+      message: this.#message,
+      metadata: {
+        capx: {
+          mode: this.options.mode,
+          runtimeServerUrl: this.options.runtimeServerUrl,
+          policyExecution: {
+            enabled: this.options.enablePolicyCodeExecution ?? false,
+            mode: this.options.enablePolicyCodeExecution ? "live-runtime" : "none",
+            activeProcessInjection: false,
+            activeRuntimeSession: true,
+            runtimeServer: "capx-agent-runtime",
+            loopOwner: "agent-core"
+          }
+        }
+      }
+    };
+  }
+  async start(options) {
+    if (this.#status === "running" || this.#status === "ready") {
+      return this.getState();
+    }
+    this.#startedAt = Date.now();
+    this.#updatedAt = this.#startedAt;
+    this.#message = void 0;
+    if (options?.task) {
+      this.options.task = options.task;
+    }
+    this.#status = "starting";
+    await this.#ensureLiveRuntime();
+    this.#status = "ready";
+    this.#message = "Connected to capx-agent-runtime live session; agent-core owns the trial loop.";
+    this.#updatedAt = Date.now();
+    return this.getState();
+  }
+  async observe(options = {}) {
+    const items = [];
+    const state = this.getState();
+    if (this.#liveRuntime) {
+      const observation = await this.#liveRuntime.observe();
+      if (observation.taskPrompt) {
+        items.push({
+          kind: "text",
+          source: "capx:runtime:task-prompt",
+          text: observation.taskPrompt,
+          timestamp: Date.now()
+        });
+      }
+      if (observation.multiTurnPrompt) {
+        items.push({
+          kind: "text",
+          source: "capx:runtime:multi-turn-prompt",
+          text: observation.multiTurnPrompt,
+          timestamp: Date.now()
+        });
+      }
+      if (observation.fullPrompt) {
+        items.push({
+          kind: "text",
+          source: "capx:runtime:full-prompt",
+          text: JSON.stringify(observation.fullPrompt, null, 2),
+          timestamp: Date.now()
+        });
+      }
+      if (observation.runtimeConfig) {
+        items.push({
+          kind: "text",
+          source: "capx:runtime:config",
+          text: JSON.stringify(observation.runtimeConfig, null, 2),
+          timestamp: Date.now()
+        });
+      }
+      if (observation.codeContext) {
+        items.push({
+          kind: "text",
+          source: "capx:runtime:code-context",
+          text: JSON.stringify(observation.codeContext, null, 2),
+          timestamp: Date.now()
+        });
+      }
+      if (observation.lastStep) {
+        items.push({
+          kind: "text",
+          source: "capx:runtime:last-step",
+          text: JSON.stringify(observation.lastStep, null, 2),
+          timestamp: Date.now()
+        });
+      }
+      if (options.includeImages) {
+        try {
+          const frame = await this.#liveRuntime.renderFrame("main");
+          if (frame.dataUrl) {
+            items.push({
+              kind: "rgb",
+              source: "capx:runtime:main-camera",
+              dataUrl: frame.dataUrl,
+              width: frame.width,
+              height: frame.height,
+              mimeType: frame.mimeType,
+              frame: "camera",
+              timestamp: frame.timestamp ? frame.timestamp * 1e3 : Date.now()
+            });
+          }
+        } catch (error) {
+          items.push({
+            kind: "text",
+            source: "capx:runtime:render-error",
+            text: error instanceof Error ? error.message : String(error),
+            timestamp: Date.now()
+          });
+        }
+      }
+    } else {
+      items.push({
+        kind: "text",
+        source: "capx:runtime:session",
+        text: "No live CaP-X runtime session has started. The host application must call session.start() or createCapxAgent({ startSession: true }) before the agent can observe or solve the current CaP-X trial.",
+        timestamp: Date.now()
+      });
+    }
+    if (this.#liveRuntime?.stdoutTail) {
+      items.push({
+        kind: "text",
+        source: "capx:runtime:stdout",
+        text: this.#liveRuntime.stdoutTail,
+        timestamp: this.#updatedAt
+      });
+    }
+    if (this.#liveRuntime?.stderrTail) {
+      items.push({
+        kind: "text",
+        source: "capx:runtime:stderr",
+        text: this.#liveRuntime.stderrTail,
+        timestamp: this.#updatedAt
+      });
+    }
+    if (options.includeArtifacts && this.listArtifacts) {
+      const artifacts = await this.listArtifacts({ limit: options.maxItems });
+      for (const artifact of artifacts) {
+        items.push({
+          kind: "artifact",
+          source: "capx:outputs",
+          data: artifact,
+          timestamp: this.#updatedAt
+        });
+      }
+    }
+    const maxItems = options.maxItems ?? items.length;
+    const selected = items.slice(0, maxItems);
+    return {
+      sessionId: this.id,
+      status: state.status,
+      taskId: state.task?.id,
+      summary: selected.length === 0 ? "No CaP-X output has been captured yet." : `${selected.length} CaP-X observation item(s) captured.`,
+      items: selected,
+      metadata: state.metadata,
+      timestamp: Date.now()
+    };
+  }
+  async reset(options) {
+    if (options?.task) {
+      this.options.task = options.task;
+    }
+    this.#status = "starting";
+    const runtime = await this.#ensureLiveRuntime();
+    await runtime.reset(this.options.policyExecutionTrial);
+    this.#status = "ready";
+    this.#message = "Reset capx-agent-runtime live session.";
+    this.#updatedAt = Date.now();
+    return this.getState();
+  }
+  async listArtifacts(options = {}) {
+    const runtime = await this.#ensureLiveRuntime();
+    const artifacts = await runtime.listArtifacts(options.limit ?? 50);
+    return options.kind ? artifacts.filter((artifact) => artifact.kind === options.kind) : artifacts;
+  }
+  async getRuntimeTurnHistory() {
+    if (!this.#liveRuntime) {
+      return [];
+    }
+    return this.#liveRuntime.turnHistory();
+  }
+  async getRuntimeSkillLibrary() {
+    if (!this.#liveRuntime) {
+      return {
+        summary: "No live CaP-X runtime session has started.",
+        total: 0,
+        promoted: 0,
+        skills: []
+      };
+    }
+    return this.#liveRuntime.skillLibrary();
+  }
+  async extractRuntimeSkills(options = {}) {
+    const runtime = await this.#ensureLiveRuntime();
+    return runtime.extractSkills(options);
+  }
+  async injectRuntimeSkillLibrary(minOccurrences = 2) {
+    const runtime = await this.#ensureLiveRuntime();
+    return runtime.injectSkillLibrary(minOccurrences);
+  }
+  async stop(reason) {
+    this.#message = reason ?? "Stop requested.";
+    this.#updatedAt = Date.now();
+    if (this.#liveRuntime) {
+      this.#status = "stopping";
+      await this.#liveRuntime.stop();
+      this.#liveRuntime = void 0;
+      this.#status = "stopped";
+      this.#updatedAt = Date.now();
+      return this.getState();
+    }
+    this.#status = "stopped";
+    return this.getState();
+  }
+};
+function createCapxSession(options) {
+  return new CapxSession(options);
+}
+function createCapxPhysicalTools(session, options = {}) {
+  const tools = createPhysicalSessionTools(session, {
+    prefix: "capx",
+    ...options
+  });
+  if (session instanceof CapxSession && session.options.policyExecutionMode === "live-runtime") {
+    tools.push(createCapxTurnHistoryTool(session, options));
+  }
+  return tools;
+}
+function capxToolName(name, options) {
+  return `${options?.prefix ?? "capx"}_${name}`;
+}
+function createCapxTurnHistoryTool(session, options) {
+  return Tool.define(
+    capxToolName("turn_history", options),
+    {
+      description: "List policy-code turns executed through the live CaP-X runtime session.",
+      parameters: z.object({}),
+      capabilities: {
+        parallelSafe: true,
+        readOnly: true,
+        riskLevel: "safe"
+      },
+      execute: async () => {
+        const turns = await session.getRuntimeTurnHistory();
+        return {
+          title: "CaP-X Turn History",
+          output: turns.length === 0 ? "No CaP-X runtime turns have executed yet." : `${turns.length} CaP-X runtime turn(s).`,
+          metadata: {
+            physical: {
+              sessionId: session.id
+            },
+            capx: {
+              turns
+            }
+          }
+        };
+      }
+    },
+    {
+      capabilitiesHint: {
+        parallelSafe: true,
+        readOnly: true,
+        riskLevel: "safe"
+      }
+    }
+  );
+}
+
+export {
+  CapxLiveRuntime,
+  CapxSession,
+  createCapxSession,
+  createCapxPhysicalTools
+};
+//# sourceMappingURL=chunk-MYO63CWO.js.map