zeitlich 0.2.16 → 0.2.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zeitlich",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "description": "[EXPERIMENTAL] An opinionated AI agent implementation for Temporal",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/src/adapters/sandbox/virtual/index.ts

@@ -77,6 +77,8 @@ export function createVirtualSandbox<
 export { VirtualSandboxFileSystem } from "./filesystem";
 export { VirtualSandboxProvider } from "./provider";
 export { withVirtualSandbox } from "./with-virtual-sandbox";
+export { hasFileWithMimeType, filesWithMimeType, hasDirectory } from "./queries";
+export type { FileTreeAccessor } from "./queries";
 export type {
   FileEntry,
   FileEntryMetadata,

package/src/adapters/sandbox/virtual/queries.ts

@@ -0,0 +1,97 @@
+import type { FileEntry } from "./types";
+
+/**
+ * Structural constraint: accepts any `AgentStateManager<T>` whose custom
+ * state includes `fileTree: FileEntry<TMeta>[]`.
+ */
+export interface FileTreeAccessor<TMeta> {
+  get(key: "fileTree"): FileEntry<TMeta>[];
+}
+
+/**
+ * Check whether any file in the tree has a `metadata.mimeType` that matches
+ * the given pattern.
+ *
+ * Patterns:
+ * - Exact: `"application/pdf"`
+ * - Wildcard type: `"image/*"`
+ *
+ * Useful for conditionally enabling tools:
+ *
+ * ```ts
+ * { enabled: hasFileWithMimeType(stateManager, "image/*") }
+ * { enabled: hasFileWithMimeType(stateManager, ["image/*", "application/pdf"]) }
+ * ```
+ */
+export function hasFileWithMimeType<TMeta>(
+  stateManager: FileTreeAccessor<TMeta>,
+  pattern: string | string[],
+): boolean {
+  const tree = stateManager.get("fileTree");
+  const matchers = (Array.isArray(pattern) ? pattern : [pattern]).map(buildMatcher);
+  return tree.some((entry) => {
+    const meta = entry.metadata as Record<string, unknown> | undefined;
+    const mime = meta?.mimeType;
+    return typeof mime === "string" && matchers.some((m) => m(mime));
+  });
+}
+
+/**
+ * Return all entries whose `metadata.mimeType` matches the given pattern.
+ */
+export function filesWithMimeType<TMeta>(
+  stateManager: FileTreeAccessor<TMeta>,
+  pattern: string,
+): FileEntry<TMeta>[] {
+  const tree = stateManager.get("fileTree");
+  const match = buildMatcher(pattern);
+  return tree.filter((entry) => {
+    const meta = entry.metadata as Record<string, unknown> | undefined;
+    const mime = meta?.mimeType;
+    return typeof mime === "string" && match(mime);
+  });
+}
+
+/**
+ * Check whether the tree contains a directory whose name matches the given
+ * pattern. Directories are inferred from file paths.
+ *
+ * Patterns:
+ * - Exact: `"src"`
+ * - Glob with `*` wildcard: `"test*"`, `"*.generated"`
+ *
+ * ```ts
+ * { enabled: hasDirectory(stateManager, "test*") }
+ * ```
+ */
+export function hasDirectory<TMeta>(
+  stateManager: FileTreeAccessor<TMeta>,
+  pattern: string,
+): boolean {
+  const tree = stateManager.get("fileTree");
+  const match = buildGlobMatcher(pattern);
+  return tree.some((entry) => {
+    const segments = entry.path.split("/").filter(Boolean);
+    return segments.slice(0, -1).some(match);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Internal matchers
+// ---------------------------------------------------------------------------
+
+function buildMatcher(pattern: string): (value: string) => boolean {
+  if (pattern.endsWith("/*")) {
+    const prefix = pattern.slice(0, -1);
+    return (v) => v.startsWith(prefix);
+  }
+  return (v) => v === pattern;
+}
+
+function buildGlobMatcher(pattern: string): (value: string) => boolean {
+  if (!pattern.includes("*")) return (v) => v === pattern;
+  const re = new RegExp(
+    "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$",
+  );
+  return (v) => re.test(v);
+}

package/src/adapters/thread/langchain/activities.ts

@@ -96,7 +96,7 @@ export function createLangChainAdapter(
 
     async forkThread(
       sourceThreadId: string,
-      targetThreadId: string,
+      targetThreadId: string
     ): Promise<void> {
       const thread = createLangChainThreadManager({
         redis,
@@ -106,18 +106,20 @@ export function createLangChainAdapter(
     },
   };
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const makeInvoker = (model: BaseChatModel<any>): ModelInvoker<StoredMessage> =>
+  const makeInvoker = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    model: BaseChatModel<any>
+  ): ModelInvoker<StoredMessage> =>
     createLangChainModelInvoker({ redis, model });
 
   const invoker: ModelInvoker<StoredMessage> = config.model
     ? makeInvoker(config.model)
-    : ((() => {
+    : () => {
         throw new Error(
           "No default model provided to createLangChainAdapter. " +
             "Either pass `model` in the config or use `createModelInvoker(model)` instead."
         );
-      }) as unknown as ModelInvoker<StoredMessage>);
+      };
 
   return {
     threadOps,

package/src/lib/session/session.integration.test.ts

@@ -850,3 +850,4 @@ describe("createSession integration", () => {
     expect(result.usage.totalOutputTokens).toBe(90);
   });
 });
+

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 | (() => 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";

package/src/lib/subagent/register.ts

@@ -13,9 +13,9 @@ import { createSubagentHandler } from "./handler";
  * Builds a fully wired tool entry for the Subagent tool,
  * including per-subagent hook delegation.
  *
- * Uses getters for `enabled`, `description`, and `schema` so that
- * dynamic changes to SubagentConfig.enabled are re-evaluated each
- * time getToolDefinitions() is called.
+ * Lazily evaluates `enabled` (supports `boolean | () => boolean`)
+ * so that `description` and `schema` reflect the current set of
+ * active subagents each time getToolDefinitions() is called.
  *
  * Returns null if no subagents are configured.
  */
@@ -24,7 +24,10 @@ export function buildSubagentRegistration(
 ): ToolMap[string] | null {
   if (subagents.length === 0) return null;
 
-  const getEnabled = (): SubagentConfig[] => subagents.filter((s) => s.enabled ?? true);
+  const getEnabled = (): SubagentConfig[] =>
+    subagents.filter((s) =>
+      typeof s.enabled === "function" ? s.enabled() : (s.enabled ?? true),
+    );
 
   const subagentHooksMap = new Map<string, SubagentHooks>();
   for (const s of subagents) {