@sequenceholdings/agent-spec 0.1.1 → 0.1.3

package/dist/agent-definition.js

@@ -0,0 +1,240 @@
+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';
+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([]),
+    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) => {
+    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/index.d.ts

@@ -1,117 +1,2 @@
-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>>;
-    aiCheckerConfig: 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';

package/dist/index.js

@@ -1,248 +1,2 @@
-import { createHash } from 'node:crypto';
-import { z } from 'zod';
-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(),
-    }),
-]);
-const inputFieldSchema = z
-    .object({
-    name: z
-        .string()
-        .min(1)
-        .regex(/^[A-Za-z_][A-Za-z0-9_]*$/, 'name must be a valid identifier'),
-    label: z.string().optional(),
-    description: z.string().optional(),
-    type: z.enum(['string', 'text', 'number', 'boolean', 'enum']),
-    required: z.boolean().optional(),
-    default: z.union([z.string(), z.number(), z.boolean()]).optional(),
-    enum: z.array(z.string()).optional(),
-    placeholder: z.string().optional(),
-})
-    .superRefine((field, context) => {
-    if (field.type === 'enum') {
-        if (field.enum === undefined || field.enum.length === 0) {
-            context.addIssue({
-                code: 'custom',
-                path: ['enum'],
-                message: 'enum fields require at least one option',
-            });
-        }
-        if (field.default !== undefined &&
-            (typeof field.default !== 'string' ||
-                !field.enum?.includes(field.default))) {
-            context.addIssue({
-                code: 'custom',
-                path: ['default'],
-                message: 'default must be one of the declared enum options',
-            });
-        }
-        return;
-    }
-    if (field.default === undefined)
-        return;
-    const expected = field.type === 'number'
-        ? 'number'
-        : field.type === 'boolean'
-            ? 'boolean'
-            : 'string';
-    if (typeof field.default !== expected) {
-        context.addIssue({
-            code: 'custom',
-            path: ['default'],
-            message: `default for ${field.type} fields must be a ${expected}`,
-        });
-    }
-});
-const inputSchemaSchema = z
-    .object({ fields: z.array(inputFieldSchema) })
-    .refine((schema) => new Set(schema.fields.map((field) => field.name)).size ===
-    schema.fields.length, {
-    path: ['fields'],
-    message: 'fields[].name must be unique within an inputSchema',
-});
-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(),
-}));
-export const agentDefinitionSchema = 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([]),
-    mcpServers: z.array(z.string()).default([]),
-    requiredMcpServers: z.array(z.string()).default([]),
-    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(),
-    aiCheckerConfig: 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(),
-})
-    .superRefine((definition, context) => {
-    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`,
-        });
-    }
-    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 function defineAgent(input) {
-    return agentDefinitionSchema.parse(input);
-}
-function sortJson(value) {
-    if (Array.isArray(value))
-        return value.map(sortJson);
-    if (value === null || typeof value !== 'object')
-        return value;
-    const object = value;
-    return Object.fromEntries(Object.keys(object)
-        .sort()
-        .filter((key) => object[key] !== undefined)
-        .map((key) => [key, sortJson(object[key])]));
-}
-export function canonicalJson(value) {
-    return JSON.stringify(sortJson(value));
-}
-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 });
-}
+export * from './agent-definition.js';
+export * from './voice.js';

package/dist/input-schema.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const inputSchemaSchema: 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";
+            text: "text";
+            enum: "enum";
+        }>;
+        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>;