@perstack/runtime 0.0.92 → 0.0.94

package/README.md

@@ -42,22 +42,26 @@ Output is JSON events (one per line) to stdout.
 
 ## Programmatic Usage
 
-The primary entry point is the `run` function. It takes a `JobSetting` object and an optional `RunOptions` object.
+The primary entry point is the `run` function. It takes a `RunSetting` object and an optional `RunOptions` object.
 
 ```typescript
 import { run } from "@perstack/runtime"
-import { type JobSetting } from "@perstack/core"
+import { type RunSetting } from "@perstack/core"
 
-// Configure the job
-const setting: JobSetting = {
+// Configure the run
+const setting: RunSetting = {
+  model: "claude-sonnet-4-20250514",
+  providerConfig: { providerName: "anthropic", apiKey: "..." },
   jobId: "job-123",
+  runId: "run-123",
   expertKey: "researcher",
   input: { text: "Research quantum computing" },
-  // ... configuration for model, experts, etc.
+  experts: { /* ... */ },
+  // ... other configuration
 }
 
 // Execute the job
-const finalJob = await run({ setting }, {
+const finalCheckpoint = await run({ setting }, {
   eventListener: (event) => {
     console.log(`[${event.type}]`, event)
   }
@@ -243,28 +247,35 @@ The runtime ensures deterministic execution through a strictly defined state mac
 stateDiagram-v2
     [*] --> Init
     Init --> PreparingForStep: startRun
+    Init --> ResumingFromStop: resumeFromStop
+
     PreparingForStep --> GeneratingToolCall: startGeneration
-    PreparingForStep --> CallingTools: resumeToolCalls
-    PreparingForStep --> FinishingStep: finishAllToolCalls
-    
-    GeneratingToolCall --> CallingTools: callTools
+
+    ResumingFromStop --> CallingInteractiveTools: proceedToInteractiveTools
+    ResumingFromStop --> ResolvingToolResult: resolveToolResults
+
+    GeneratingToolCall --> CallingMcpTools: callTools
     GeneratingToolCall --> FinishingStep: retry
+    GeneratingToolCall --> Stopped: stopRunByError
+    GeneratingToolCall --> Stopped: completeRun
 
-    CallingTools --> ResolvingToolResults: resolveToolResults
-    CallingTools --> ResolvingThought: resolveThought
-    CallingTools --> GeneratingRunResult: attemptCompletion
-    CallingTools --> CallingDelegate: callDelegates
-    CallingTools --> CallingInteractiveTool: callInteractiveTool
+    CallingMcpTools --> ResolvingToolResult: resolveToolResults
+    CallingMcpTools --> GeneratingRunResult: attemptCompletion
+    CallingMcpTools --> CallingDelegates: finishMcpTools
+    CallingMcpTools --> Stopped: completeRun
 
-    ResolvingToolResults --> FinishingStep: finishToolCall
-    ResolvingThought --> FinishingStep: finishToolCall
+    CallingDelegates --> Stopped: stopRunByDelegate
+    CallingDelegates --> CallingInteractiveTools: skipDelegates
+
+    CallingInteractiveTools --> Stopped: stopRunByInteractiveTool
+    CallingInteractiveTools --> ResolvingToolResult: resolveToolResults
+
+    ResolvingToolResult --> FinishingStep: finishToolCall
 
     GeneratingRunResult --> Stopped: completeRun
     GeneratingRunResult --> FinishingStep: retry
+    GeneratingRunResult --> Stopped: stopRunByError
 
-    CallingInteractiveTool --> Stopped: stopRunByInteractiveTool
-    CallingDelegate --> Stopped: stopRunByDelegate
-    
     FinishingStep --> PreparingForStep: continueToNextStep
     FinishingStep --> Stopped: stopRunByExceededMaxSteps
 ```
@@ -272,12 +283,11 @@ stateDiagram-v2
 ### Events
 Events trigger state transitions. They are emitted by the runtime logic or external inputs.
 
-- **Lifecycle**: `startRun`, `startGeneration`, `continueToNextStep`, `completeRun`
-- **Tool Execution**: `callTools`, `resolveToolResults`, `finishToolCall`, `resumeToolCalls`, `finishAllToolCalls`
-- **Special Types**: `resolveThought`
-- **Delegation**: `callDelegate` (triggers new Run(s) for delegate(s), parallel when multiple)
-- **Interactive**: `callInteractiveTool` (Coordinator only)
-- **Interruption**: `stopRunByInteractiveTool`, `stopRunByDelegate`, `stopRunByExceededMaxSteps`
+- **Lifecycle**: `startRun`, `resumeFromStop`, `startGeneration`, `continueToNextStep`, `completeRun`
+- **Tool Execution**: `callTools`, `resolveToolResults`, `finishToolCall`, `finishMcpTools`, `attemptCompletion`
+- **Delegation**: `skipDelegates` (internal state transition)
+- **Interactive**: `proceedToInteractiveTools` (for resuming to interactive tools)
+- **Interruption**: `stopRunByInteractiveTool`, `stopRunByDelegate`, `stopRunByExceededMaxSteps`, `stopRunByError`
 - **Error Handling**: `retry`
 
 ## Checkpoint Status
@@ -287,71 +297,12 @@ The `status` field in a Checkpoint indicates the current state:
 - `init`, `proceeding` — Run lifecycle
 - `completed` — Task finished successfully
 - `stoppedByInteractiveTool`, `stoppedByDelegate` — Waiting for external input
-- `stoppedByExceededMaxSteps`, `stoppedByError` — Run stopped
+- `stoppedByExceededMaxSteps`, `stoppedByError`, `stoppedByCancellation` — Run stopped
 
 For stop reasons and error handling, see [Error Handling](https://github.com/perstack-ai/perstack/blob/main/docs/using-experts/error-handling.md).
 
-## Runtime Adapters
-
-The runtime supports multiple execution backends through the adapter pattern. External runtime adapters are provided as separate packages:
-
-| Package                 | Runtime Name  | Description                        |
-| ----------------------- | ------------- | ---------------------------------- |
-| `@perstack/docker`      | `docker`      | Docker containerized (default)     |
-| `@perstack/runtime`     | `local`       | Built-in runtime without isolation |
-| `@perstack/cursor`      | `cursor`      | Cursor IDE headless mode           |
-| `@perstack/claude-code` | `claude-code` | Claude Code CLI                    |
-| `@perstack/gemini`      | `gemini`      | Gemini CLI                         |
-
-### Registration Pattern
-
-External adapters must be registered before use:
-
-```typescript
-import { CursorAdapter } from "@perstack/cursor"
-import { getAdapter, isAdapterAvailable, registerAdapter } from "@perstack/runtime"
-
-// Register external adapter
-registerAdapter("cursor", () => new CursorAdapter())
-
-// Check availability
-if (isAdapterAvailable("cursor")) {
-  const adapter = getAdapter("cursor")
-  const result = await adapter.checkPrerequisites()
-  if (result.ok) {
-    await adapter.run({ setting, eventListener })
-  }
-}
-```
-
-### Creating Custom Adapters
-
-Extend `BaseAdapter` from `@perstack/core` for CLI-based runtimes:
-
-```typescript
-import { BaseAdapter, type AdapterRunParams, type AdapterRunResult, type PrerequisiteResult } from "@perstack/core"
-
-class MyAdapter extends BaseAdapter {
-  readonly name = "my-runtime"
-  
-  async checkPrerequisites(): Promise<PrerequisiteResult> {
-    const result = await this.execCommand(["my-cli", "--version"])
-    return result.exitCode === 0
-      ? { ok: true }
-      : { ok: false, error: { type: "cli-not-found", message: "..." } }
-  }
-  
-  async run(params: AdapterRunParams): Promise<AdapterRunResult> {
-    // Implementation
-  }
-}
-```
-
-See [Multi-Runtime Support](https://github.com/perstack-ai/perstack/blob/main/docs/using-experts/multi-runtime.md) for details.
-
 ## Related Documentation
 
 - [Runtime](https://github.com/perstack-ai/perstack/blob/main/docs/understanding-perstack/runtime.md) — Full execution model
 - [State Management](https://github.com/perstack-ai/perstack/blob/main/docs/using-experts/state-management.md) — Jobs, Runs, and Checkpoints
 - [Running Experts](https://github.com/perstack-ai/perstack/blob/main/docs/using-experts/running-experts.md) — CLI usage
-- [Multi-Runtime](https://github.com/perstack-ai/perstack/blob/main/docs/using-experts/multi-runtime.md) — Multi-runtime support

package/dist/bin/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { package_default, findLockfile, loadLockfile, run } from '../chunk-SIMOIKWR.js';
+import { package_default, findLockfile, loadLockfile, run } from '../chunk-ZVUNZKPP.js';
 import '../chunk-RG4QHAGG.js';
 import { parseWithFriendlyError, runCommandInputSchema, validateEventFilter, createFilteredEventListener, perstackConfigSchema } from '@perstack/core';
 import { Command } from 'commander';

package/dist/{chunk-SIMOIKWR.js → chunk-ZVUNZKPP.js}

@@ -3,6 +3,7 @@ import { readFileSync } from 'fs';
 import path from 'path';
 import { parseWithFriendlyError, lockfileSchema, runParamsSchema, createRuntimeEvent, knownModels, stopRunByExceededMaxSteps, continueToNextStep, stopRunByError, retry, createStreamingEvent, completeRun, finishToolCall, resolveToolResults, stopRunByInteractiveTool, skipDelegates, stopRunByDelegate, attemptCompletion, finishMcpTools, callTools, proceedToInteractiveTools, startGeneration, startRun, resumeFromStop } from '@perstack/core';
 import TOML from 'smol-toml';
+import { createId } from '@paralleldrive/cuid2';
 import { createAmazonBedrock } from '@ai-sdk/amazon-bedrock';
 import { createAnthropic } from '@ai-sdk/anthropic';
 import { createAzure } from '@ai-sdk/azure';
@@ -12,7 +13,6 @@ import { createVertex } from '@ai-sdk/google-vertex';
 import { createOpenAI } from '@ai-sdk/openai';
 import { createOllama } from 'ollama-ai-provider-v2';
 import { ProxyAgent, fetch } from 'undici';
-import { createId } from '@paralleldrive/cuid2';
 import { setup, assign, createActor } from 'xstate';
 import { readFile } from 'fs/promises';
 import { dedent } from 'ts-dedent';
@@ -21,7 +21,7 @@ import { APICallError, generateText, streamText } from 'ai';
 // package.json
 var package_default = {
   name: "@perstack/runtime",
-  version: "0.0.92",
+  version: "0.0.94",
   description: "Perstack Runtime",
   author: "Wintermute Technologies, Inc.",
   license: "Apache-2.0",
@@ -75,7 +75,6 @@ var package_default = {
     xstate: "^5.25.1"
   },
   devDependencies: {
-    "@perstack/adapter-base": "workspace:*",
     "@perstack/anthropic-provider": "workspace:*",
     "@perstack/azure-openai-provider": "workspace:*",
     "@perstack/bedrock-provider": "workspace:*",
@@ -146,107 +145,6 @@ function getLockfileExpertToolDefinitions(lockfileExpert) {
   }
   return result;
 }
-function createProxyFetch(proxyUrl) {
-  const agent = new ProxyAgent(proxyUrl);
-  return (input, init) => {
-    return fetch(input, { ...init, dispatcher: agent });
-  };
-}
-function getModel(modelId, providerConfig, options) {
-  const customFetch = options?.proxyUrl ? createProxyFetch(options.proxyUrl) : void 0;
-  switch (providerConfig.providerName) {
-    case "anthropic": {
-      const anthropic = createAnthropic({
-        apiKey: providerConfig.apiKey,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers,
-        fetch: customFetch
-      });
-      return anthropic(modelId);
-    }
-    case "google": {
-      const google = createGoogleGenerativeAI({
-        apiKey: providerConfig.apiKey,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers,
-        fetch: customFetch
-      });
-      return google(modelId);
-    }
-    case "openai": {
-      const openai = createOpenAI({
-        apiKey: providerConfig.apiKey,
-        baseURL: providerConfig.baseUrl,
-        organization: providerConfig.organization,
-        project: providerConfig.project,
-        name: providerConfig.name,
-        headers: providerConfig.headers,
-        fetch: customFetch
-      });
-      return openai(modelId);
-    }
-    case "ollama": {
-      const ollama = createOllama({
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers,
-        fetch: customFetch
-      });
-      return ollama(modelId);
-    }
-    case "azure-openai": {
-      const azure = createAzure({
-        apiKey: providerConfig.apiKey,
-        resourceName: providerConfig.resourceName,
-        apiVersion: providerConfig.apiVersion,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers,
-        useDeploymentBasedUrls: providerConfig.useDeploymentBasedUrls,
-        fetch: customFetch
-      });
-      return azure(modelId);
-    }
-    case "amazon-bedrock": {
-      const amazonBedrock = createAmazonBedrock({
-        accessKeyId: providerConfig.accessKeyId,
-        secretAccessKey: providerConfig.secretAccessKey,
-        region: providerConfig.region,
-        sessionToken: providerConfig.sessionToken,
-        fetch: customFetch
-      });
-      return amazonBedrock(modelId);
-    }
-    case "google-vertex": {
-      const vertex = createVertex({
-        project: providerConfig.project,
-        location: providerConfig.location,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers,
-        fetch: customFetch
-      });
-      return vertex(modelId);
-    }
-    case "deepseek": {
-      const deepseek = createDeepSeek({
-        apiKey: providerConfig.apiKey,
-        baseURL: providerConfig.baseUrl,
-        headers: providerConfig.headers,
-        fetch: customFetch
-      });
-      return deepseek(modelId);
-    }
-    default: {
-      const _exhaustive = providerConfig;
-      throw new Error(`Unknown provider: ${_exhaustive.providerName}`);
-    }
-  }
-}
-function getContextWindow(providerName, modelId) {
-  const modelConfig = knownModels.find((model) => model.provider === providerName)?.models.find((model) => model.name === modelId);
-  return modelConfig?.contextWindow;
-}
-function calculateContextWindowUsage(usage, contextWindow) {
-  return (usage.inputTokens + usage.cachedInputTokens + usage.outputTokens) / contextWindow;
-}
 
 // src/helpers/usage.ts
 function createEmptyUsage() {
@@ -345,6 +243,13 @@ function buildDelegationReturnState(currentSetting, resultCheckpoint, parentChec
     }
   };
 }
+function getContextWindow(providerName, modelId) {
+  const modelConfig = knownModels.find((model) => model.provider === providerName)?.models.find((model) => model.name === modelId);
+  return modelConfig?.contextWindow;
+}
+function calculateContextWindowUsage(usage, contextWindow) {
+  return (usage.inputTokens + usage.cachedInputTokens + usage.outputTokens) / contextWindow;
+}
 
 // src/helpers/runtime-version.ts
 function parseRuntimeVersion(version) {
@@ -2035,7 +1940,11 @@ var StateMachineCoordinator = class {
       if (!shouldContinue) {
         this.actor?.stop();
         await this.closeManagers(runState.context.skillManagers);
-        this.resolvePromise?.(runState.context.checkpoint);
+        const cancelledCheckpoint = {
+          ...runState.context.checkpoint,
+          status: "stoppedByCancellation"
+        };
+        this.resolvePromise?.(cancelledCheckpoint);
         return;
       }
     }
@@ -3654,7 +3563,6 @@ var SingleRunExecutor = class {
     if (!this.options.eventListener) return;
     const initEvent = createRuntimeEvent("initializeRuntime", setting.jobId, setting.runId, {
       runtimeVersion: package_default.version,
-      runtime: "local",
       expertName: expertToRun.name,
       experts: Object.keys(experts),
       model: setting.model,
@@ -3762,12 +3670,16 @@ async function run(runInput, options) {
         storeJob({ ...job, status: "stoppedByError", finishedAt: Date.now() });
         return resultCheckpoint;
       }
+      case "stoppedByCancellation": {
+        storeJob({ ...job, status: "stoppedByCancellation", finishedAt: Date.now() });
+        return resultCheckpoint;
+      }
       default:
         throw new Error("Run stopped by unknown reason");
     }
   }
 }
 
-export { findLockfile, getLockfileExpertToolDefinitions, getModel, loadLockfile, package_default, run, runtimeStateMachine };
-//# sourceMappingURL=chunk-SIMOIKWR.js.map
-//# sourceMappingURL=chunk-SIMOIKWR.js.map
+export { findLockfile, getLockfileExpertToolDefinitions, loadLockfile, package_default, run, runtimeStateMachine };
+//# sourceMappingURL=chunk-ZVUNZKPP.js.map
+//# sourceMappingURL=chunk-ZVUNZKPP.js.map