@plasm_lang/vercel-agent 0.3.63

package/src/tools/plasm-tools.ts

@@ -0,0 +1,104 @@
+import { tool } from "ai";
+import { z } from "zod";
+
+import type { AgentRuntime } from "../runtime/agent-runtime.js";
+import {
+  DISCOVER_TOOL_DESCRIPTION,
+  PLASM_CONTEXT_TOOL_DESCRIPTION,
+  PLASM_RUN_TOOL_DESCRIPTION,
+  PLASM_TOOL_DESCRIPTION,
+} from "./descriptions.js";
+
+const seedSchema = z.object({
+  api: z.string().describe("Registry entry_id / catalog api"),
+  entity: z.string().describe("CGS entity name from discovery or prior knowledge"),
+});
+
+export function createPlasmTools(runtime: AgentRuntime) {
+  return {
+    discover_capabilities: tool({
+      description: DISCOVER_TOOL_DESCRIPTION,
+      inputSchema: z.object({
+        intent: z
+          .string()
+          .min(1)
+          .describe(
+            "One plain-language task description for the whole user goal. Returns catalog api/entity picks — not program symbols.",
+          ),
+      }),
+      execute: async ({ intent }) => runtime.discoverCapabilities({ intent }),
+    }),
+
+    plasm_context: tool({
+      description: PLASM_CONTEXT_TOOL_DESCRIPTION,
+      inputSchema: z.object({
+        intent: z
+          .string()
+          .min(1)
+          .describe(
+            "Stable string for one user goal (same value every turn for that goal — do not rotate per message).",
+          ),
+        seeds: z
+          .array(seedSchema)
+          .min(1)
+          .describe("Non-empty array of {api, entity} capability picks"),
+        ranked_capabilities: z
+          .array(z.string())
+          .nullable()
+          .optional()
+          .describe(
+            "Optional capability wire names from discover_capabilities. Omit on expand; null or [] clears.",
+          ),
+      }),
+      execute: async ({ intent, seeds, ranked_capabilities }) =>
+        runtime.plasmContext({
+          intent,
+          seeds,
+          rankedCapabilities: ranked_capabilities,
+        }),
+    }),
+
+    plasm: tool({
+      description: PLASM_TOOL_DESCRIPTION,
+      inputSchema: z.object({
+        logical_session_ref: z
+          .string()
+          .describe("Same logical_session_ref returned by plasm_context"),
+        program: z
+          .string()
+          .min(1)
+          .describe("Plasm source program using e#/m#/p#/r# from the session teaching TSV"),
+        reasoning: z
+          .string()
+          .optional()
+          .describe("Optional short note explaining the intent of this call"),
+      }),
+      execute: async ({ logical_session_ref, program, reasoning }) =>
+        runtime.plasm({ logicalSessionRef: logical_session_ref, program, reasoning }),
+    }),
+
+    plasm_run: tool({
+      description: PLASM_RUN_TOOL_DESCRIPTION,
+      inputSchema: z.object({
+        logical_session_ref: z
+          .string()
+          .describe("Same logical_session_ref returned by plasm_context"),
+        plan_commit_ref: z
+          .string()
+          .describe("Executable plan token (pcN) from a prior plasm dry-run"),
+        reasoning: z
+          .string()
+          .optional()
+          .describe("Optional short note explaining the intent of this call"),
+      }),
+      execute: async ({ logical_session_ref, plan_commit_ref, reasoning }) =>
+        runtime.plasmRun({
+          logicalSessionRef: logical_session_ref,
+          planCommitRef: plan_commit_ref,
+          reasoning,
+        }),
+    }),
+  };
+}
+
+export type PlasmTools = ReturnType<typeof createPlasmTools>;

package/src/workflow/world-bootstrap.ts

@@ -0,0 +1,52 @@
+import type { AgentWorkflowDefinition } from "../define-agent.js";
+
+export type WorkflowWorldType = "local" | "postgres" | "vercel";
+
+export function resolveWorkflowWorldType(
+  definition?: AgentWorkflowDefinition,
+): WorkflowWorldType {
+  const fromDef = definition?.world?.type;
+  if (fromDef === "local" || fromDef === "postgres" || fromDef === "vercel") {
+    return fromDef;
+  }
+  const env = process.env.PLASM_WORKFLOW_WORLD?.trim().toLowerCase();
+  if (env === "local" || env === "postgres" || env === "vercel") {
+    return env;
+  }
+  if (process.env.VERCEL === "1") return "vercel";
+  return "local";
+}
+
+/**
+ * Bootstrap Workflow SDK world from agent definition.
+ * - `vercel`: platform-managed world on deploy (no-op here)
+ * - `postgres`: `@workflow/world-postgres` long-lived worker
+ * - `local`: `@workflow/world-local` for dev
+ */
+export async function bootstrapWorkflowWorld(
+  definition?: AgentWorkflowDefinition,
+): Promise<WorkflowWorldType> {
+  const worldType = resolveWorkflowWorldType(definition);
+  if (worldType === "vercel") {
+    return worldType;
+  }
+
+  if (worldType === "postgres") {
+    process.env.WORKFLOW_TARGET_WORLD ??= "@workflow/world-postgres";
+    process.env.WORKFLOW_POSTGRES_URL ??=
+      process.env.DATABASE_URL?.trim() ||
+      process.env.PLASM_STATE_POSTGRES_URL?.trim();
+  } else {
+    process.env.WORKFLOW_TARGET_WORLD ??= "@workflow/world-local";
+  }
+
+  try {
+    const { getWorld } = await import("workflow/runtime");
+    const world = getWorld();
+    await world.start?.();
+  } catch (err) {
+    if (process.env.PLASM_WORKFLOW_STRICT === "1") throw err;
+  }
+
+  return worldType;
+}