@sequenceholdings/agent-spec 0.1.2 → 0.1.4

package/dist/agent-definition.js

@@ -0,0 +1,250 @@
+import { createHash } from 'node:crypto';
+import { z } from 'zod';
+import { inputSchemaSchema } from './input-schema.js';
+import { canonicalJson, sortJson } from './canonical-json.js';
+import { voiceDeclarationSchema } from './voice-authoring.js';
+import { clientProposalsSchema } from './client-proposals.js';
+export { canonicalJson } from './canonical-json.js';
+export { voiceDeclarationSchema } from './voice-authoring.js';
+const OBJECT_ID_PATTERN = /^[0-9a-f]{24}$/;
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const DEFAULT_MODEL = {
+    provider: 'anthropic',
+    name: 'claude-sonnet-4-5-20250929',
+};
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const unsupportedConstraints = {
+    integer: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'],
+    number: ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum'],
+    array: ['minItems', 'maxItems', 'uniqueItems'],
+    string: ['minLength', 'maxLength', 'format', 'pattern'],
+};
+export function collectUnsupportedConstraints({ schema, path = '', }) {
+    if (schema === null || typeof schema !== 'object')
+        return [];
+    const object = schema;
+    const type = typeof object.type === 'string' ? object.type : undefined;
+    const violations = [];
+    if (type !== undefined) {
+        for (const keyword of unsupportedConstraints[type] ?? []) {
+            if (keyword in object) {
+                violations.push({ path: path || '(root)', type, keyword });
+            }
+        }
+    }
+    if (type === 'object' &&
+        object.properties !== null &&
+        typeof object.properties === 'object') {
+        for (const [key, value] of Object.entries(object.properties)) {
+            violations.push(...collectUnsupportedConstraints({
+                schema: value,
+                path: `${path}.properties.${key}`,
+            }));
+        }
+    }
+    if (type === 'array' && object.items !== undefined) {
+        violations.push(...collectUnsupportedConstraints({
+            schema: object.items,
+            path: `${path}.items`,
+        }));
+    }
+    for (const combinator of ['anyOf', 'oneOf', 'allOf', 'prefixItems']) {
+        const entries = object[combinator];
+        if (!Array.isArray(entries))
+            continue;
+        entries.forEach((entry, index) => {
+            violations.push(...collectUnsupportedConstraints({
+                schema: entry,
+                path: `${path}.${combinator}[${index}]`,
+            }));
+        });
+    }
+    return violations;
+}
+const modelSchema = z.object({
+    provider: z.string().min(1),
+    name: z.string().min(1),
+});
+export const AGENT_PERMISSION_ROLES = [
+    'owner',
+    'editor',
+    'invoker',
+    'outputs_viewer',
+];
+const permissionGrantSchema = z.object({
+    type: z.enum(['user', 'group']),
+    id: z.string().min(1),
+    role: z.enum(AGENT_PERMISSION_ROLES),
+});
+const subagentSchema = z.union([
+    z.string().min(1),
+    z.object({
+        id: z.string().min(1),
+        forkContext: z.boolean().optional(),
+    }),
+]);
+export const AGENT_REFERENCE_KINDS = ['mcp_server', 'skill', 'subagent', 'managed_function'];
+export const agentReferenceSchema = z.strictObject({
+    kind: z.enum(AGENT_REFERENCE_KINDS),
+    id: z.string().min(1),
+});
+const openaiCodeInterpreterSchema = z.preprocess((value) => {
+    if (value === true)
+        return { enabled: true };
+    if (value === false)
+        return { enabled: false };
+    return value;
+}, z.object({
+    enabled: z.boolean(),
+    containerId: z.string().min(1).optional(),
+    fileIds: z.array(z.string().min(1)).optional(),
+}));
+const textDefinitionBaseSchema = z
+    .strictObject({
+    id: z
+        .string()
+        .regex(OBJECT_ID_PATTERN, 'id must be a 24-character lowercase hex ObjectId'),
+    name: z.string().min(1),
+    description: z.string().optional(),
+    framework: z.enum(['vercel', 'claude-agent']).optional(),
+    vmBackend: z.enum(['gce', 'e2b']).optional(),
+    idleTimeoutSeconds: z.number().int().min(60).max(86_400).optional(),
+    agentCapabilities: jsonObjectSchema.nullish(),
+    claudeToolSearch: z.enum(['enabled', 'disabled', 'auto']).optional(),
+    claudeBuiltInTools: z.array(z.string()).default([]),
+    openaiCodeInterpreter: openaiCodeInterpreterSchema.nullish(),
+    model: modelSchema.default(DEFAULT_MODEL),
+    thinking: jsonObjectSchema.nullish(),
+    reasoningEffort: z.string().nullish(),
+    temperature: z.number().min(0).max(1).nullish(),
+    systemPrompt: z.string().optional(),
+    tools: z.array(z.string()).default([]),
+    clientProposals: clientProposalsSchema.optional(),
+    mcpServers: z.array(z.string()).default([]),
+    requiredMcpServers: z.array(z.string()).default([]),
+    requiredReferences: z.array(agentReferenceSchema).optional(),
+    managedFunctions: z.array(z.string().min(1)).optional(),
+    excludedMcpTools: z.array(z.string()).default([]),
+    hideIntermediateText: z.boolean().optional(),
+    middleware: z.array(z.string()).default([]),
+    subagents: z.array(subagentSchema).default([]),
+    skills: z.array(z.string()).default([]),
+    contextFileIds: z.array(z.string()).default([]),
+    structuredOutput: jsonObjectSchema.optional(),
+    inputSchema: inputSchemaSchema.nullish(),
+    promptTemplate: z.string().optional(),
+    webhooks: jsonObjectSchema.optional(),
+    mcpServerConfigs: jsonObjectSchema.optional(),
+    stubConfig: jsonObjectSchema.nullish(),
+    maxTtlSeconds: z.number().int().positive().optional(),
+    agentPermissions: z.array(jsonObjectSchema).optional(),
+    apiPermissions: z.array(z.string()).optional(),
+    managedBy: z.literal('automation').nullish(),
+    isPublic: z.boolean().optional(),
+    publicOutputs: z.boolean().optional(),
+    permissions: z.array(permissionGrantSchema).optional(),
+});
+export const textAgentDefinitionSchema = textDefinitionBaseSchema.safeExtend({
+    mode: z.literal('text').optional(),
+    voice: z.never().optional(),
+}).superRefine((definition, context) => {
+    if (definition.framework === 'claude-agent' && (definition.clientProposals?.length ?? 0) > 0) {
+        context.addIssue({ code: 'custom', path: ['clientProposals'], message: 'Client proposals require the Vercel tool runtime' });
+    }
+    for (const [index, proposal] of (definition.clientProposals ?? []).entries()) {
+        if (definition.tools.includes(proposal.name)) {
+            context.addIssue({ code: 'custom', path: ['clientProposals', index, 'name'], message: 'Client proposal name collides with a selected built-in tool' });
+        }
+    }
+    for (const [index, serverId] of definition.requiredMcpServers.entries()) {
+        if (definition.mcpServers.includes(serverId))
+            continue;
+        context.addIssue({
+            code: 'custom',
+            path: ['requiredMcpServers', index],
+            message: `requiredMcpServers entry "${serverId}" must also appear in mcpServers`,
+        });
+    }
+    const declaredByKind = {
+        managed_function: new Set(definition.managedFunctions ?? []),
+        mcp_server: new Set(definition.mcpServers),
+        skill: new Set(definition.skills),
+        subagent: new Set(definition.subagents.map((entry) => typeof entry === 'string' ? entry : entry.id)),
+    };
+    for (const [index, reference] of (definition.requiredReferences ?? []).entries()) {
+        if (declaredByKind[reference.kind].has(reference.id))
+            continue;
+        context.addIssue({
+            code: 'custom',
+            path: ['requiredReferences', index],
+            message: `requiredReferences entry ${reference.kind} "${reference.id}" must also be declared on the agent`,
+        });
+    }
+    if (definition.structuredOutput?.enabled === true) {
+        const schema = definition.structuredOutput.schema;
+        for (const violation of collectUnsupportedConstraints({ schema })) {
+            context.addIssue({
+                code: 'custom',
+                path: ['structuredOutput', 'schema'],
+                message: `${violation.path}: "${violation.keyword}" on ${violation.type} is not supported`,
+            });
+        }
+    }
+});
+export const voiceAgentDefinitionSchema = textDefinitionBaseSchema.pick({
+    id: true, name: true, description: true, permissions: true,
+}).extend({
+    mode: z.literal('voice'),
+    model: z.strictObject({ provider: z.string().trim().min(1).max(200), name: z.string().trim().min(1).max(200) }),
+    systemPrompt: z.string().min(1).max(100_000).refine((text) => text.trim().length > 0, 'Prompt must contain text'),
+    skills: z.array(z.string().trim().min(1).max(200)).max(32).default([])
+        .refine((ids) => new Set(ids).size === ids.length, 'Duplicate native Skill reference')
+        .transform((ids) => [...ids].sort()),
+    voice: voiceDeclarationSchema,
+    isPublic: z.literal(false).optional(),
+    publicOutputs: z.literal(false).optional(),
+}).superRefine((definition, context) => {
+    const captured = new Set(definition.voice.procedures.map((item) => item.source.skillId));
+    if (definition.skills.length !== captured.size || definition.skills.some((id) => !captured.has(id))) {
+        context.addIssue({ code: 'custom', path: ['skills'], message: 'Native Skill references must match captured Voice procedures' });
+    }
+});
+export const agentDefinitionSchema = z.discriminatedUnion('mode', [
+    textAgentDefinitionSchema, voiceAgentDefinitionSchema,
+]);
+export function defineAgent(input) {
+    return agentDefinitionSchema.parse(input);
+}
+export function getAgentMode({ definition }) {
+    return definition.mode ?? 'text';
+}
+export function validateAgentModeUpdate({ existing, incoming }) {
+    const parsed = agentDefinitionSchema.parse(incoming);
+    if (existing.id !== parsed.id)
+        throw new Error('Agent identity cannot change across versions');
+    if (getAgentMode({ definition: existing }) !== getAgentMode({ definition: parsed })) {
+        throw new Error('Agent mode cannot change across versions');
+    }
+    return parsed;
+}
+export function canonicalAgentJson(definition) {
+    return canonicalJson(definition);
+}
+export function hashAgentBundle({ definitions, }) {
+    const canonical = [...definitions]
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map(canonicalAgentJson)
+        .join('\n');
+    return createHash('sha256').update('sequence-agent-bundle-v1\0').update(canonical).digest('hex');
+}
+export function formatAgentSource({ definition, exportName = 'agent', }) {
+    if (!IDENTIFIER_PATTERN.test(exportName)) {
+        throw new Error('exportName must be a valid TypeScript identifier');
+    }
+    const object = JSON.stringify(sortJson(definition), null, 2);
+    return ("import { defineAgent } from '@sequenceholdings/agent-spec'\n\n" +
+        `export const ${exportName} = defineAgent(${object})\n`);
+}
+export function generateAgentSource({ definition, exportName = 'agent', }) {
+    return formatAgentSource({ definition: defineAgent(definition), exportName });
+}

package/dist/canonical-json.d.ts

@@ -0,0 +1,2 @@
+export declare function sortJson(value: unknown): unknown;
+export declare function canonicalJson(value: unknown): string;

package/dist/canonical-json.js

@@ -0,0 +1,13 @@
+export function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    if (value === null || typeof value !== 'object')
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+        .filter(([, nested]) => nested !== undefined)
+        .map(([key, nested]) => [key, sortJson(nested)]));
+}
+export function canonicalJson(value) {
+    return JSON.stringify(sortJson(value));
+}

package/dist/client-proposals.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const CLIENT_PROPOSAL_LIMITS: {
+    readonly count: 64;
+    readonly descriptionLength: 32000;
+    readonly schemaBytes: number;
+    readonly totalBytes: number;
+    readonly schemaDepth: 32;
+    readonly schemaNodes: 10000;
+};
+export declare const clientProposalSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>;
+export type ClientProposal = z.infer<typeof clientProposalSchema>;
+export declare const clientProposalsSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    inputSchema: z.ZodPipe<z.ZodUnknown, z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>>;

package/dist/client-proposals.js

@@ -0,0 +1,172 @@
+import { z } from 'zod';
+export const CLIENT_PROPOSAL_LIMITS = {
+    count: 64, descriptionLength: 32_000, schemaBytes: 128 * 1024,
+    totalBytes: 512 * 1024, schemaDepth: 32, schemaNodes: 10_000,
+};
+const TYPES = new Set(['object', 'array', 'string', 'number', 'integer', 'boolean', 'null']);
+const RESERVED_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
+const ANNOTATIONS = new Set(['$schema', 'title', 'description']);
+const NUMBER_KEYS = new Set(['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum']);
+const SIZE_KEYS = new Set(['minLength', 'maxLength', 'minItems', 'maxItems']);
+const CHILD_KEYS = new Set(['items', 'additionalProperties', 'propertyNames']);
+const UNION_KEYS = new Set(['anyOf', 'oneOf', 'allOf']);
+const KEYWORDS = new Set([...ANNOTATIONS, ...NUMBER_KEYS, ...SIZE_KEYS, ...CHILD_KEYS, ...UNION_KEYS,
+    'type', 'properties', 'required', 'enum', 'const']);
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function requireBoundedJson(value) {
+    const seen = new Set();
+    const pending = [{ value, depth: 0 }];
+    let nodes = 0;
+    while (pending.length > 0) {
+        const item = pending.pop();
+        if (!item)
+            break;
+        if (++nodes > CLIENT_PROPOSAL_LIMITS.schemaNodes || item.depth > CLIENT_PROPOSAL_LIMITS.schemaDepth) {
+            throw new Error('Client proposal schema exceeds its depth or node limit');
+        }
+        const current = item.value;
+        if (typeof current === 'string' && Buffer.byteLength(current) > CLIENT_PROPOSAL_LIMITS.schemaBytes) {
+            throw new Error('Client proposal schema exceeds its byte limit');
+        }
+        if (current === null || typeof current === 'string' || typeof current === 'boolean')
+            continue;
+        if (typeof current === 'number' && Number.isFinite(current))
+            continue;
+        if (typeof current !== 'object' || current === null)
+            throw new Error('Client proposal schema must be literal JSON');
+        requireLiteralContainer({ current, seen, pending, depth: item.depth });
+    }
+    if (Buffer.byteLength(JSON.stringify(value)) > CLIENT_PROPOSAL_LIMITS.schemaBytes) {
+        throw new Error('Client proposal schema exceeds its byte limit');
+    }
+}
+function requireLiteralContainer({ current, seen, pending, depth }) {
+    const prototype = Object.getPrototypeOf(current);
+    if ((!Array.isArray(current) && prototype !== Object.prototype && prototype !== null) || seen.has(current)) {
+        throw new Error('Client proposal schema must be acyclic literal JSON');
+    }
+    seen.add(current);
+    const keys = Reflect.ownKeys(current);
+    if (Array.isArray(current))
+        requireLiteralArray({ value: current, keys });
+    for (const key of keys) {
+        if (Array.isArray(current) && key === 'length')
+            continue;
+        if (typeof key !== 'string' || RESERVED_NAMES.has(key))
+            throw new Error('Client proposal schema contains an unsupported key');
+        const descriptor = Object.getOwnPropertyDescriptor(current, key);
+        if (!descriptor || !('value' in descriptor) || !descriptor.enumerable)
+            throw new Error('Client proposal schema must contain JSON values');
+        pending.push({ value: descriptor.value, depth: depth + 1 });
+    }
+}
+function requireLiteralArray({ value, keys }) {
+    if (Object.getPrototypeOf(value) !== Array.prototype || keys.length !== value.length + 1) {
+        throw new Error('Client proposal schema arrays must be dense literal JSON');
+    }
+    for (let index = 0; index < value.length; index++) {
+        if (!Object.hasOwn(value, String(index)))
+            throw new Error('Client proposal schema arrays must be dense literal JSON');
+    }
+}
+function requireType(value) {
+    const types = Array.isArray(value) ? value : [value];
+    if (types.length === 0 || types.length > TYPES.size || types.some(type => typeof type !== 'string' || !TYPES.has(type))
+        || new Set(types).size !== types.length)
+        throw new Error('Client proposal schema has an invalid type');
+}
+function requireProperties(value) {
+    if (!isObject(value) || Object.keys(value).length > 512)
+        throw new Error('Client proposal properties must be a bounded object');
+    for (const child of Object.values(value))
+        requireSchema(child);
+}
+function requireRequired({ value, properties }) {
+    if (!Array.isArray(value) || value.some(name => typeof name !== 'string') || new Set(value).size !== value.length) {
+        throw new Error('Client proposal required must contain unique property names');
+    }
+    if (value.some(name => !isObject(properties) || !Object.hasOwn(properties, name))) {
+        throw new Error('Client proposal required must name declared properties');
+    }
+}
+function requireBound({ key, value }) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        throw new Error(`Client proposal ${key} must be a finite number`);
+    if (SIZE_KEYS.has(key) && (!Number.isSafeInteger(value) || value < 0)) {
+        throw new Error(`Client proposal ${key} must be a nonnegative integer`);
+    }
+}
+function requireEntry({ key, entry, schema }) {
+    if (!KEYWORDS.has(key))
+        throw new Error(`Unsupported client proposal schema keyword: ${key}`);
+    if (ANNOTATIONS.has(key)) {
+        if (typeof entry !== 'string')
+            throw new Error(`Client proposal ${key} must be a string`);
+    }
+    else if (NUMBER_KEYS.has(key) || SIZE_KEYS.has(key))
+        requireBound({ key, value: entry });
+    else if (key === 'type')
+        requireType(entry);
+    else if (CHILD_KEYS.has(key))
+        requireSchema(entry);
+    else if (UNION_KEYS.has(key)) {
+        if (!Array.isArray(entry) || entry.length === 0 || entry.length > 32)
+            throw new Error(`Client proposal ${key} requires 1–32 schemas`);
+        for (const child of entry)
+            requireSchema(child);
+    }
+    else if (key === 'properties')
+        requireProperties(entry);
+    else if (key === 'required')
+        requireRequired({ value: entry, properties: schema.properties });
+    else if (key === 'enum') {
+        if (!Array.isArray(entry) || entry.length === 0 || entry.length > 512)
+            throw new Error('Client proposal enum must be a bounded nonempty array');
+    }
+}
+function requireSchema(value) {
+    if (typeof value === 'boolean')
+        return;
+    if (!isObject(value))
+        throw new Error('Client proposal schema nodes must be objects or booleans');
+    for (const [key, entry] of Object.entries(value))
+        requireEntry({ key, entry, schema: value });
+}
+const literalJsonSchema = z.unknown().superRefine((value, context) => {
+    try {
+        requireBoundedJson(value);
+    }
+    catch (error) {
+        context.addIssue({ code: 'custom', message: error instanceof Error ? error.message : 'Invalid client proposal JSON' });
+    }
+});
+const proposalInputSchema = literalJsonSchema.pipe(z.record(z.string(), z.unknown())).superRefine((value, context) => {
+    try {
+        if (value.type !== 'object')
+            throw new Error('Client proposal root schema type must be object');
+        requireSchema(value);
+    }
+    catch (error) {
+        context.addIssue({ code: 'custom', message: error instanceof Error ? error.message : 'Invalid client proposal schema' });
+    }
+});
+export const clientProposalSchema = z.strictObject({
+    name: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]{0,63}$/).refine(name => !RESERVED_NAMES.has(name), 'Reserved client proposal name'),
+    description: z.string().min(1).max(CLIENT_PROPOSAL_LIMITS.descriptionLength),
+    inputSchema: proposalInputSchema,
+});
+export const clientProposalsSchema = z.array(clientProposalSchema).max(CLIENT_PROPOSAL_LIMITS.count).superRefine((value, context) => {
+    if (new Set(value.map(proposal => proposal.name)).size !== value.length) {
+        context.addIssue({ code: 'custom', message: 'Client proposal names must be unique' });
+    }
+    try {
+        if (Buffer.byteLength(JSON.stringify(value)) > CLIENT_PROPOSAL_LIMITS.totalBytes) {
+            context.addIssue({ code: 'custom', message: 'Client proposal descriptors exceed their total byte limit' });
+        }
+    }
+    catch {
+        context.addIssue({ code: 'custom', message: 'Client proposal descriptors must be literal JSON' });
+    }
+});

package/dist/index.d.ts

@@ -1,116 +1,4 @@
-import { z } from 'zod';
-export type UnsupportedConstraint = {
-    path: string;
-    type: string;
-    keyword: string;
-};
-export declare function collectUnsupportedConstraints({ schema, path, }: {
-    schema: unknown;
-    path?: string;
-}): UnsupportedConstraint[];
-export declare const AGENT_PERMISSION_ROLES: readonly ["owner", "editor", "invoker", "outputs_viewer"];
-export type AgentPermissionRole = (typeof AGENT_PERMISSION_ROLES)[number];
-export declare const agentDefinitionSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    framework: z.ZodOptional<z.ZodEnum<{
-        vercel: "vercel";
-        "claude-agent": "claude-agent";
-    }>>;
-    vmBackend: z.ZodOptional<z.ZodEnum<{
-        gce: "gce";
-        e2b: "e2b";
-    }>>;
-    idleTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
-    agentCapabilities: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    claudeToolSearch: z.ZodOptional<z.ZodEnum<{
-        enabled: "enabled";
-        disabled: "disabled";
-        auto: "auto";
-    }>>;
-    claudeBuiltInTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    openaiCodeInterpreter: z.ZodOptional<z.ZodNullable<z.ZodPreprocess<z.ZodObject<{
-        enabled: z.ZodBoolean;
-        containerId: z.ZodOptional<z.ZodString>;
-        fileIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>>;
-    model: z.ZodDefault<z.ZodObject<{
-        provider: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strip>>;
-    thinking: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    reasoningEffort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    systemPrompt: z.ZodOptional<z.ZodString>;
-    tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    mcpServers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    requiredMcpServers: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    excludedMcpTools: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    hideIntermediateText: z.ZodOptional<z.ZodBoolean>;
-    middleware: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    subagents: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        forkContext: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>]>>>;
-    skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    contextFileIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    structuredOutput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    inputSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-        fields: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            type: z.ZodEnum<{
-                string: "string";
-                number: "number";
-                boolean: "boolean";
-                enum: "enum";
-                text: "text";
-            }>;
-            required: z.ZodOptional<z.ZodBoolean>;
-            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
-            enum: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            placeholder: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-    promptTemplate: z.ZodOptional<z.ZodString>;
-    webhooks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    mcpServerConfigs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    stubConfig: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    maxTtlSeconds: z.ZodOptional<z.ZodNumber>;
-    agentPermissions: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    apiPermissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    managedBy: z.ZodOptional<z.ZodNullable<z.ZodLiteral<"automation">>>;
-    isPublic: z.ZodOptional<z.ZodBoolean>;
-    publicOutputs: z.ZodOptional<z.ZodBoolean>;
-    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            user: "user";
-            group: "group";
-        }>;
-        id: z.ZodString;
-        role: z.ZodEnum<{
-            owner: "owner";
-            editor: "editor";
-            invoker: "invoker";
-            outputs_viewer: "outputs_viewer";
-        }>;
-    }, z.core.$strip>>>;
-}, z.core.$strict>;
-export type AgentDefinition = z.infer<typeof agentDefinitionSchema>;
-export type AgentDefinitionInput = z.input<typeof agentDefinitionSchema>;
-export declare function defineAgent(input: AgentDefinitionInput): AgentDefinition;
-export declare function canonicalJson(value: unknown): string;
-export declare function canonicalAgentJson(definition: AgentDefinition): string;
-export declare function hashAgentBundle({ definitions, }: {
-    definitions: AgentDefinition[];
-}): string;
-export declare function formatAgentSource({ definition, exportName, }: {
-    definition: unknown;
-    exportName?: string;
-}): string;
-export declare function generateAgentSource({ definition, exportName, }: {
-    definition: AgentDefinition;
-    exportName?: string;
-}): string;
+export * from './agent-definition.js';
+export * from './voice.js';
+export * from './job-request-hash.js';
+export * from './client-proposals.js';