@comma-agents/core 2.0.0-rc.0 → 2.0.0-rc.1

package/dist/agents/agent/agent.types.d.ts

@@ -1,5 +1,5 @@
-import type { AbortableAsyncGenerator, AbortablePromise } from "../../abortable";
 import type { tool as aiTool, CallSettings, FlexibleSchema, LanguageModel, ModelMessage, StepResult, stepCountIs, streamText, ToolChoice } from "ai";
+import type { AbortableAsyncGenerator, AbortablePromise } from "../../abortable";
 import type { ContextUsage, ConversationContext, ConversationContextOptions, ConversationRetentionEvent, ResponseMessage } from "../../conversation-context";
 import type { LanguageService } from "../../language";
 import type { PromptTemplate, TemplateVariables } from "../../prompts";
@@ -73,7 +73,7 @@ export interface AgentConfig {
      * Skill registry exposed to the `load_skill` tool when included in `tools`.
      * When omitted, `load_skill` returns `skill_unavailable` for every call.
      * Typically populated by the strategy loader from
-     * `<configRoot>/comma-agents/skills/` plus `./.comma/skills/`.
+     * `~/.comma/skills/` plus `./.comma/skills/`.
      */
     readonly skillRegistry?: SkillRegistry;
     /**

package/dist/agents/loader/index.d.ts

@@ -1,4 +1,4 @@
 export { loadAgent, loadAgentFromString } from "./loader";
-export type { AgentDescription } from "./loader.schema";
-export { AgentDescriptionSchema } from "./loader.schema";
+export type { AgentDescription, CustomAgentDescription, LLMAgentDescription, } from "./loader.schema";
+export { AgentDescriptionSchema, CustomAgentDescriptionSchema, LLMAgentDescriptionSchema, } from "./loader.schema";
 export type { LoadAgentOptions } from "./loader.types";

package/dist/agents/loader/loader.d.ts

@@ -8,8 +8,7 @@ import type { LoadAgentOptions } from "./loader.types";
  * live `Agent` ready to call.
  *
  * @param filePath - Absolute or relative path to the agent description file.
- * @param options  - Hooks, abort signal.
- *                   Optional — when omitted, global defaults are used for model resolution.
+ * @param options - Runtime services and optional model override.
  * @returns A live Agent instance.
  * @throws {StrategyValidationError} If the file is invalid or missing required fields.
  *
@@ -31,8 +30,7 @@ export declare function loadAgent(filePath: string, options?: LoadAgentOptions):
  *
  * @param content - The raw agent description string.
  * @param format  - "json" or "yaml".
- * @param options - Hooks, abort signal.
- *                  Optional — when omitted, global defaults are used for model resolution.
+ * @param options - Runtime services and optional model override.
  * @returns A live Agent instance.
  * @throws {StrategyValidationError} If parsing or validation fails.
  *
@@ -46,4 +44,4 @@ export declare function loadAgent(filePath: string, options?: LoadAgentOptions):
  * const agent = await loadAgentFromString(yaml, "yaml");
  * ```
  */
-export declare function loadAgentFromString(content: string, format: "json" | "yaml", _options?: LoadAgentOptions): Promise<Agent>;
+export declare function loadAgentFromString(content: string, format: "json" | "yaml", options?: LoadAgentOptions): Promise<Agent>;

package/dist/agents/loader/loader.schema.d.ts

@@ -16,11 +16,9 @@ export declare const SystemPromptTemplateSchema: z.ZodObject<{
     variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
 }>;
 /**
- * Model-level generation parameters forwarded to `streamText`.
- *
- * These are provider-agnostic options supported by virtually every LLM
- * provider. Provider-specific features (extended thinking, reasoning
- * effort) should use `providerOptions` instead.
+ * Provider-independent generation parameters applied to every model call.
+ * Provider-specific features such as extended thinking or reasoning effort
+ * belong in `providerOptions` instead.
  */
 export declare const ModelOptionsSchema: z.ZodObject<{
     temperature: z.ZodOptional<z.ZodNumber>;
@@ -89,7 +87,7 @@ export declare const ConversationContextSchema: z.ZodObject<{
     } | undefined;
 }>;
 /**
- * Agent description schema — validates a standalone agent description file.
+ * Standalone LLM-backed agent description.
  *
  * @example
  * ```yaml
@@ -97,13 +95,15 @@ export declare const ConversationContextSchema: z.ZodObject<{
  * model: openai/gpt-4o
  * systemPrompt: You are a research assistant.
  * tools:
- *   - read
- *   - grep
+ *   - read_file
+ *   - search_files
  * ```
  */
-export declare const AgentDescriptionSchema: z.ZodObject<{
+export declare const LLMAgentDescriptionSchema: z.ZodObject<{
     /** Unique name for this agent. */
     name: z.ZodString;
+    /** Built-in LLM agent type. May be omitted. */
+    type: z.ZodOptional<z.ZodLiteral<"llm">>;
     /** Optional human-readable description. */
     description: z.ZodOptional<z.ZodString>;
     /** Model string in "providerID/modelID" format (e.g., "openai/gpt-4o"). */
@@ -124,9 +124,8 @@ export declare const AgentDescriptionSchema: z.ZodObject<{
     /** Tool names to make available to the agent. */
     tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     /**
-     * Per-call provider options forwarded verbatim to the AI SDK. Used to
-     * enable provider-specific features such as Anthropic extended thinking
-     * or OpenAI reasoning effort. Shape:
+     * Per-call options for provider-specific features such as extended
+     * thinking or reasoning effort. Shape:
      * `{ <providerId>: { <option>: <value>, ... }, ... }`.
      */
     providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
@@ -205,13 +204,47 @@ export declare const AgentDescriptionSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     name: string;
     model: string;
+    type?: "llm" | undefined;
     description?: string | undefined;
+    tools?: string[] | undefined;
     systemPrompt?: string | undefined;
     systemPromptTemplate?: {
         template: string;
         variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
     } | undefined;
+    providerOptions?: Record<string, Record<string, unknown>> | undefined;
+    modelOptions?: {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    } | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    context?: {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    } | undefined;
+    maxSteps?: number | undefined;
+}, {
+    name: string;
+    model: string;
+    type?: "llm" | undefined;
+    description?: string | undefined;
     tools?: string[] | undefined;
+    systemPrompt?: string | undefined;
+    systemPromptTemplate?: {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    } | undefined;
     providerOptions?: Record<string, Record<string, unknown>> | undefined;
     modelOptions?: {
         temperature?: number | undefined;
@@ -234,16 +267,175 @@ export declare const AgentDescriptionSchema: z.ZodObject<{
         } | undefined;
     } | undefined;
     maxSteps?: number | undefined;
+}>;
+/** Standalone registered agent description with implementation-specific configuration. */
+export declare const CustomAgentDescriptionSchema: z.ZodObject<{
+    /** Unique name for this agent. */
+    name: z.ZodString;
+    /** Optional human-readable description. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Name registered with `registerAgent`. */
+    type: z.ZodEffects<z.ZodString, string, string>;
+    /** Configuration validated by the registered agent type. */
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    config?: Record<string, unknown> | undefined;
 }, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+}>;
+/** A standalone built-in LLM or registered custom agent description. */
+export declare const AgentDescriptionSchema: z.ZodUnion<[z.ZodObject<{
+    /** Unique name for this agent. */
+    name: z.ZodString;
+    /** Built-in LLM agent type. May be omitted. */
+    type: z.ZodOptional<z.ZodLiteral<"llm">>;
+    /** Optional human-readable description. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Model string in "providerID/modelID" format (e.g., "openai/gpt-4o"). */
+    model: z.ZodString;
+    /** Static system prompt sent to the model. Mutually exclusive with systemPromptTemplate. */
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    /** Dynamic system prompt using Liquid template syntax. */
+    systemPromptTemplate: z.ZodOptional<z.ZodObject<{
+        template: z.ZodString;
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString, "many">, z.ZodRecord<z.ZodString, z.ZodString>]>>>;
+    }, "strict", z.ZodTypeAny, {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    }, {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    }>>;
+    /** Tool names to make available to the agent. */
+    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Per-call options for provider-specific features such as extended
+     * thinking or reasoning effort. Shape:
+     * `{ <providerId>: { <option>: <value>, ... }, ... }`.
+     */
+    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    /** Model-level generation parameters (temperature, maxTokens, etc.). */
+    modelOptions: z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        topK: z.ZodOptional<z.ZodNumber>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+        frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+        presencePenalty: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    }, {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    }>>;
+    /** JSON Schema describing the agent's structured output. */
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Conversation context retention and compaction controls. */
+    context: z.ZodOptional<z.ZodObject<{
+        rollingWindow: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodObject<{
+            maxRecords: z.ZodNumber;
+        }, "strict", z.ZodTypeAny, {
+            maxRecords: number;
+        }, {
+            maxRecords: number;
+        }>]>>;
+        compaction: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+            keepRecent: z.ZodOptional<z.ZodNumber>;
+            threshold: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        }, {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        }>]>>;
+    }, "strict", z.ZodTypeAny, {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    }, {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    }>>;
+    /**
+     * Maximum number of LLM round-trips (steps) per call.
+     * Each tool-call + response counts as one step.
+     */
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
     name: string;
     model: string;
+    type?: "llm" | undefined;
     description?: string | undefined;
+    tools?: string[] | undefined;
     systemPrompt?: string | undefined;
     systemPromptTemplate?: {
         template: string;
         variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
     } | undefined;
+    providerOptions?: Record<string, Record<string, unknown>> | undefined;
+    modelOptions?: {
+        temperature?: number | undefined;
+        topP?: number | undefined;
+        topK?: number | undefined;
+        maxOutputTokens?: number | undefined;
+        maxRetries?: number | undefined;
+        frequencyPenalty?: number | undefined;
+        presencePenalty?: number | undefined;
+        seed?: number | undefined;
+    } | undefined;
+    outputSchema?: Record<string, unknown> | undefined;
+    context?: {
+        rollingWindow?: number | {
+            maxRecords: number;
+        } | undefined;
+        compaction?: boolean | {
+            keepRecent?: number | undefined;
+            threshold?: number | undefined;
+        } | undefined;
+    } | undefined;
+    maxSteps?: number | undefined;
+}, {
+    name: string;
+    model: string;
+    type?: "llm" | undefined;
+    description?: string | undefined;
     tools?: string[] | undefined;
+    systemPrompt?: string | undefined;
+    systemPromptTemplate?: {
+        template: string;
+        variables?: Record<string, string | number | boolean | string[] | Record<string, string>> | undefined;
+    } | undefined;
     providerOptions?: Record<string, Record<string, unknown>> | undefined;
     modelOptions?: {
         temperature?: number | undefined;
@@ -266,5 +458,26 @@ export declare const AgentDescriptionSchema: z.ZodObject<{
         } | undefined;
     } | undefined;
     maxSteps?: number | undefined;
-}>;
+}>, z.ZodObject<{
+    /** Unique name for this agent. */
+    name: z.ZodString;
+    /** Optional human-readable description. */
+    description: z.ZodOptional<z.ZodString>;
+    /** Name registered with `registerAgent`. */
+    type: z.ZodEffects<z.ZodString, string, string>;
+    /** Configuration validated by the registered agent type. */
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+}, {
+    type: string;
+    name: string;
+    description?: string | undefined;
+    config?: Record<string, unknown> | undefined;
+}>]>;
+export type LLMAgentDescription = z.infer<typeof LLMAgentDescriptionSchema>;
+export type CustomAgentDescription = z.infer<typeof CustomAgentDescriptionSchema>;
 export type AgentDescription = z.infer<typeof AgentDescriptionSchema>;

package/dist/agents/loader/loader.types.d.ts

@@ -1,15 +1,16 @@
+import type { AgentTypeRuntime } from "../registry/agent-registry.types";
 /**
- * Options for loading an agent from a description file.
+ * Options for loading a built-in or registered custom agent.
  *
- * All fields are optional. Model and tool resolution are handled
- * internally by `createAgent()` using the global provider registry
- * (`registerProvider()`), model registry (`registerModel()`), and
- * tool registry (`registerTool()`).
+ * Runtime fields are forwarded to registered factories. Applicable fields are
+ * also passed to built-in LLM agents.
  *
  * @example
  * ```ts
- * // Zero-config — uses global credential store and provider resolver
- * const agent = await loadAgent("./agents/researcher.yaml");
+ * const agent = await loadAgent("./agents/researcher.yaml", {
+ *   modelOverride: "openai/gpt-4o",
+ * });
  * ```
  */
-export type LoadAgentOptions = Record<never, never>;
+export interface LoadAgentOptions extends AgentTypeRuntime {
+}

package/dist/agents/registry/agent-registry.constants.d.ts

@@ -0,0 +1 @@
+export declare const BUILT_IN_AGENT_NAMES: readonly ["llm", "user"];

package/dist/agents/registry/agent-registry.d.ts

@@ -0,0 +1,38 @@
+import type { z } from "zod";
+import type { AgentTypeDefinition, RegisteredAgentFactory } from "./agent-registry.types";
+/**
+ * Preserve schema inference when declaring a reusable custom agent type.
+ *
+ * @param definition - Configuration schema and factory for the custom agent.
+ * @returns The unchanged agent definition with inferred configuration types.
+ * @example
+ * ```ts
+ * const echoAgent = defineAgentType({
+ *   configSchema: z.object({ prefix: z.string() }),
+ *   create: ({ name, config }) => createAgent({
+ *     name,
+ *     execute: async (message) => `${config.prefix}${message}`,
+ *   }),
+ * });
+ * ```
+ */
+export declare function defineAgentType<ConfigSchema extends z.ZodTypeAny>(definition: AgentTypeDefinition<ConfigSchema>): AgentTypeDefinition<ConfigSchema>;
+/**
+ * Register a custom agent type for use in strategy and standalone agent files.
+ *
+ * @param name - Value referenced by a declarative agent's `type` field.
+ * @param definition - Configuration schema and factory for the custom agent.
+ * @example
+ * ```ts
+ * registerAgent("echo", echoAgent);
+ * ```
+ */
+export declare function registerAgent<ConfigSchema extends z.ZodTypeAny>(name: string, definition: AgentTypeDefinition<ConfigSchema>): void;
+/** Remove a custom agent registration. Built-in agent types remain available. */
+export declare function unregisterAgent(name: string): boolean;
+/** Return the currently registered custom agent type names. */
+export declare function getRegisteredAgentNames(): readonly string[];
+/** @internal Resolve a custom agent factory by type name. */
+export declare function resolveRegisteredAgent(name: string): RegisteredAgentFactory | undefined;
+/** Reset custom agent registrations. Primarily intended for test isolation. */
+export declare function resetAgentRegistry(): void;

package/dist/agents/registry/agent-registry.types.d.ts

@@ -0,0 +1,58 @@
+import type { z } from "zod";
+import type { LanguageService } from "../../language";
+import type { SkillRegistry } from "../../skills/skills.types";
+import type { LaunchStrategyHandle } from "../../tools/launch-strategy.types";
+import type { Agent } from "../agent/agent.types";
+import type { InputCollector } from "../built-in/user/user-agent.types";
+/** Loader-provided services available when constructing a registered agent type. */
+export interface AgentTypeRuntime {
+    /**
+     * Input collector used by interactive agents and tools.
+     * Required when a factory creates a user agent that requests input.
+     */
+    readonly inputCollector?: InputCollector;
+    /**
+     * Model override supplied for the current load operation.
+     * Custom factories decide whether and how to apply it.
+     */
+    readonly modelOverride?: string;
+    /** Skill registry available to agents and skill-aware tools. */
+    readonly skillRegistry?: SkillRegistry;
+    /** Base directory for resolving paths referenced by the loaded definition. */
+    readonly strategyDir?: string;
+    /** Runtime handle for launching sub-strategies from tools or custom agents. */
+    readonly launchStrategy?: LaunchStrategyHandle;
+    /** Language service available to language-aware tools. */
+    readonly languageService?: LanguageService;
+    /**
+     * Identifier for the current strategy invocation.
+     * Factories can pass it to agents and tools that isolate state by run.
+     */
+    readonly runId?: string;
+}
+/** Context passed to a registered custom agent factory. */
+export interface AgentTypeContext<Config> {
+    /** Name declared for this agent instance. */
+    readonly name: string;
+    /** Custom configuration validated by the agent type's schema. */
+    readonly config: Config;
+    /** Loader-provided services for the current invocation. */
+    readonly runtime: AgentTypeRuntime;
+}
+/** Definition used to validate and construct a reusable declarative agent type. */
+export interface AgentTypeDefinition<ConfigSchema extends z.ZodTypeAny> {
+    /** Schema for the agent definition's `config` object. */
+    readonly configSchema: ConfigSchema;
+    /** Create a runnable agent from validated configuration and runtime services. */
+    readonly create: (context: AgentTypeContext<z.output<ConfigSchema>>) => Agent | Promise<Agent>;
+}
+/** @internal Invalidated context used by declarative agent loaders. */
+export interface RegisteredAgentContext {
+    readonly name: string;
+    readonly config: unknown;
+    readonly runtime: AgentTypeRuntime;
+}
+/** @internal Type-erased registered factory used after registration. */
+export interface RegisteredAgentFactory {
+    readonly create: (context: RegisteredAgentContext) => Promise<Agent>;
+}

package/dist/agents/registry/index.d.ts

@@ -0,0 +1,2 @@
+export { defineAgentType, getRegisteredAgentNames, registerAgent, resetAgentRegistry, unregisterAgent, } from "./agent-registry";
+export type { AgentTypeContext, AgentTypeDefinition, AgentTypeRuntime, } from "./agent-registry.types";

package/dist/credentials/backends/json-file.d.ts

@@ -14,7 +14,7 @@ export interface JsonFileBackendOptions {
  *
  * @example
  * ```ts
- * const backend = createJsonFileBackend({ filePath: "/home/user/.config/credentials.json" });
+ * const backend = createJsonFileBackend({ filePath: "/home/user/.comma/credentials.json" });
  * const data = await backend.readAll();
  * ```
  */

package/dist/credentials/credentials.constants.d.ts

@@ -1,4 +1,6 @@
 import type { EnvVarMap } from "./credentials.types";
+/** Default name for the credentials JSON file. */
+export declare const CREDENTIALS_FILENAME = "credentials.json";
 /**
  * Well-known environment variable names for common AI providers.
  *

package/dist/credentials/credentials.utils.d.ts

@@ -1,22 +1,3 @@
-/**
- * Resolve the platform-aware data directory for comma-agents.
- *
- * Respects platform conventions:
- * - macOS:   ~/Library/Application Support/comma-agents/
- * - Windows: %LOCALAPPDATA%/comma-agents/ (fallback ~/AppData/Local)
- * - Linux:   $XDG_DATA_HOME/comma-agents/ (fallback ~/.local/share)
- *
- * @example
- * ```ts
- * const dataDir = resolveDataDir();
- * // macOS:   "/Users/alice/Library/Application Support/comma-agents"
- * // Linux:   "/home/alice/.local/share/comma-agents"
- * // Windows: "C:\\Users\\alice\\AppData\\Local\\comma-agents"
- * ```
- */
-export declare function resolveDataDir(): string;
-/** Default name for the credentials JSON file. */
-export declare const CREDENTIALS_FILENAME = "credentials.json";
 /**
  * Resolve the default path to the credentials JSON file.
  *

package/dist/credentials/index.d.ts

@@ -3,4 +3,4 @@ export { createCredentialStore } from "./credentials";
 export type { ApiCredential, Credential, CustomCredential, OAuthCredential, } from "./credentials.schema";
 export { ApiCredentialSchema, CredentialSchema, CustomCredentialSchema, OAuthCredentialSchema, } from "./credentials.schema";
 export type { AuthStatus, CreateCredentialStoreOptions, CredentialBackend, CredentialStore, CredentialStoreData, EnvVarMap, } from "./credentials.types";
-export { resolveCredentialsPath, resolveDataDir } from "./credentials.utils";
+export { resolveCredentialsPath } from "./credentials.utils";

package/dist/data-directory/data-directory.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Resolve the shared CommaAgents directory in the current user's home directory.
+ *
+ * @example
+ * ```ts
+ * const dataDirectory = resolveDataDir();
+ * // Unix:   "/home/alice/.comma"
+ * // Windows: "C:\\Users\\Alice\\.comma"
+ * ```
+ */
+export declare function resolveDataDir(): string;

package/dist/data-directory/index.d.ts

@@ -0,0 +1 @@
+export { resolveDataDir } from "./data-directory";

package/dist/defaults/defaults.d.ts

@@ -40,7 +40,7 @@ export declare function setGlobalCredentialStore(store: CredentialStore | undefi
  *
  * @example
  * ```ts
- * setProviderCacheDir("/Users/bot/.local/share/comma-agents/providers");
+ * setProviderCacheDir("/Users/bot/.comma/providers");
  * ```
  */
 export declare function setProviderCacheDir(dir: string | undefined): void;

package/dist/flows/index.d.ts

@@ -4,3 +4,5 @@ export { createSequentialFlow } from "./built-in/sequential/sequential-flow";
 export { buildFlowAgent, createFlow } from "./flow/flow";
 export type { BroadcastFlowConfig, CustomFlowConfig, CycleFlowConfig, CycleHooks, FlowConfig, FlowContext, FlowExecutor, FlowHooks, FlowResult, } from "./flow/flow.types";
 export { hookIntoFlow } from "./hook-into-flow/hook-into-flow";
+export type { FlowTypeContext, FlowTypeDefinition } from "./registry";
+export { defineFlowType, getRegisteredFlowNames, registerFlow, resetFlowRegistry, unregisterFlow, } from "./registry";