zeitlich 0.2.15 → 0.2.17

package/src/lib/subagent/define.ts

@@ -1,71 +1,58 @@
 import type { z } from "zod";
 import type {
   SubagentConfig,
-  SubagentHandlerResponse,
+  SubagentDefinition,
   SubagentHooks,
+  SubagentWorkflow,
 } from "./types";
 import type { SubagentArgs } from "./tool";
 
 /**
- * Identity function that provides full type inference for subagent configurations.
- * Verifies the workflow function's input parameters match the configured context,
- * and properly types the lifecycle hooks with Task tool args and inferred result type.
+ * Creates a `SubagentConfig` from a `SubagentDefinition` (returned by `defineSubagentWorkflow`).
+ * Metadata (name, description, resultSchema) is read from the definition — only configure
+ * what's specific to this usage in the parent workflow.
  *
  * @example
  * ```ts
- * // With typed context — workflow must accept { prompt, context }
- * const researcher = defineSubagent({
- *   name: "researcher",
- *   description: "Researches topics",
- *   workflow: researcherWorkflow, // (input: { prompt: string; context: { apiKey: string } }) => Promise<...>
- *   context: { apiKey: "..." },
- *   resultSchema: z.object({ findings: z.string() }),
+ * // Minimal — all metadata comes from the definition
+ * export const researcher = defineSubagent(researcherWorkflow);
+ *
+ * // With parent-specific overrides
+ * export const researcher = defineSubagent(researcherWorkflow, {
+ *   allowThreadContinuation: true,
+ *   sandbox: "own",
  *   hooks: {
- *     onPostExecution: ({ result }) => {
- *       // result is typed as { findings: string }
- *     },
+ *     onPostExecution: ({ result }) => console.log(result),
  *   },
  * });
  *
- * // Without context — workflow only needs { prompt }
- * const writer = defineSubagent({
- *   name: "writer",
- *   description: "Writes content",
- *   workflow: writerWorkflow, // (input: { prompt: string }) => Promise<...>
- *   resultSchema: z.object({ content: z.string() }),
+ * // With typed context
+ * export const researcher = defineSubagent(researcherWorkflow, {
+ *   context: { apiKey: "..." },
  * });
  * ```
  */
-// With context — verifies workflow accepts { prompt, context: TContext }
 export function defineSubagent<
   TResult extends z.ZodType = z.ZodType,
   TContext extends Record<string, unknown> = Record<string, unknown>,
 >(
-  config: Omit<SubagentConfig<TResult>, "hooks" | "workflow" | "context"> & {
-    workflow:
-      | string
-      | ((input: {
-          prompt: string;
-          previousThreadId?: string;
-          context: TContext;
-        }) => Promise<SubagentHandlerResponse<z.infer<TResult> | null>>);
-    context: TContext;
-    hooks?: SubagentHooks<SubagentArgs, z.infer<TResult>>;
-  }
-): SubagentConfig<TResult>;
-// Without context — verifies workflow accepts { prompt }
-export function defineSubagent<TResult extends z.ZodType = z.ZodType>(
-  config: Omit<SubagentConfig<TResult>, "hooks" | "workflow"> & {
-    workflow:
-      | string
-      | ((input: {
-          prompt: string;
-          previousThreadId?: string;
-        }) => Promise<SubagentHandlerResponse<z.infer<TResult> | null>>);
+  definition: SubagentDefinition<TResult, TContext>,
+  overrides?: {
+    context?: TContext;
     hooks?: SubagentHooks<SubagentArgs, z.infer<TResult>>;
-  }
-): SubagentConfig<TResult>;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function defineSubagent(config: any): SubagentConfig {
-  return config;
+    enabled?: boolean;
+    taskQueue?: string;
+    allowThreadContinuation?: boolean;
+    sandbox?: "inherit" | "own";
+  },
+): SubagentConfig<TResult> {
+  return {
+    agentName: definition.agentName,
+    description: definition.description,
+    workflow: definition as SubagentWorkflow<TResult>,
+    ...(definition.resultSchema !== undefined && {
+      resultSchema: definition.resultSchema,
+    }),
+    ...overrides,
+  } as SubagentConfig<TResult>;
 }

package/src/lib/subagent/handler.ts

@@ -5,7 +5,7 @@ import type { ToolMessageContent } from "../types";
 import type {
   InferSubagentResult,
   SubagentConfig,
-  SubagentInput,
+  SubagentWorkflowInput,
 } from "./types";
 import type { SubagentArgs } from "./tool";
 import type { z } from "zod";
@@ -38,18 +38,21 @@ export function createSubagentHandler<
     const { sandboxId: parentSandboxId } = context;
     const inheritSandbox = config.sandbox !== "own" && !!parentSandboxId;
 
-    const input: SubagentInput = {
-      prompt: args.prompt,
-      ...(config.context && { context: config.context }),
+    const workflowInput: SubagentWorkflowInput = {
       ...(args.threadId &&
         args.threadId !== null &&
-        config.allowThreadContinuation && { previousThreadId: args.threadId }),
+        config.allowThreadContinuation && {
+          previousThreadId: args.threadId,
+        }),
       ...(inheritSandbox && { sandboxId: parentSandboxId }),
     };
 
     const childOpts = {
       workflowId: childWorkflowId,
-      args: [input] as const,
+      args:
+        config.context === undefined
+          ? ([args.prompt, workflowInput] as const)
+          : ([args.prompt, workflowInput, config.context] as const),
       taskQueue: config.taskQueue ?? parentTaskQueue,
     };
 

package/src/lib/subagent/index.ts

@@ -1,13 +1,16 @@
 export type {
   SubagentConfig,
+  SubagentDefinition,
   SubagentHooks,
-  SubagentInput,
   SubagentHandlerResponse,
   SubagentWorkflow,
+  SubagentWorkflowInput,
+  SubagentSessionInput,
   InferSubagentResult,
 } from "./types";
 export { createSubagentTool, SUBAGENT_TOOL_NAME } from "./tool";
 export type { SubagentArgs } from "./tool";
 export { createSubagentHandler } from "./handler";
 export { defineSubagent } from "./define";
+export { defineSubagentWorkflow } from "./workflow";
 export { buildSubagentRegistration } from "./register";