Templates (SDK)

const templates = await client.listTemplates(
  options?: ListTemplatesOptions
): Promise<TemplateList>;

interface ListTemplatesOptions {
  /** Filter by industry. */
  industry?: 'legal' | 'finance' | 'devops' | 'marketing' | 'custom';
 
  /** Filter by tags. */
  tags?: string[];
 
  /** Search by name or description. */
  search?: string;
 
  limit?: number;
  offset?: number;
}

const { templates, total } = await client.listTemplates({
  industry: 'legal',
  search: 'contract',
});
 
templates.forEach((t) => {
  console.log(`${t.name} (${t.id})`);
  console.log(`  ${t.description}`);
  console.log(`  Steps: ${t.steps.length}, Est. cost: $${t.estimatedCost}`);
});

const template = await client.getTemplate(templateId: string): Promise<Template>;

interface Template {
  id: string;
  name: string;
  description: string;
  version: string;
  industry: string;
  tags: string[];
  author: string;
  steps: PlanStep[];
  inputSchema: JSONSchema;       // Required inputs
  outputSchema?: JSONSchema;     // Expected output format
  estimatedCost: number;         // USD estimate per execution
  estimatedDurationMs: number;
  hitlSteps: string[];           // Steps with HITL enabled
  createdAt: string;
  updatedAt: string;
}

const execution = await client.deployTemplate(
  templateId: string,
  options: DeployTemplateOptions
): Promise<PlanExecution>;

interface DeployTemplateOptions {
  /** Input data matching the template's inputSchema. */
  input: Record<string, unknown>;
 
  /** Override default models for specific steps. */
  modelOverrides?: Record<string, string>;
 
  /** Override default queues for specific steps. */
  queueOverrides?: Record<string, string>;
 
  /** HITL configuration overrides. */
  hitl?: HitlConfig;
 
  /** Whether to wait for completion. Default: false */
  wait?: boolean;
 
  /** Timeout when wait=true. Default: 300000 */
  timeoutMs?: number;
}

const execution = await client.deployTemplate('contract-review-v1', {
  input: {
    contract: contractText,
    jurisdiction: 'New York',
    reviewDepth: 'comprehensive',
  },
  modelOverrides: {
    'analyze-risk': 'opus', // Use Opus for the risk step
  },
  hitl: {
    requiredFor: ['analyze-risk'],
    confidenceThreshold: 0.90,
  },
  wait: true,
  timeoutMs: 180_000,
});
 
console.log('Review complete:', execution.status);
console.log('Report:', execution.steps['generate-report'].output);

const template = await client.createTemplate(
  options: CreateTemplateOptions
): Promise<Template>;

const template = await client.createTemplate({
  name: 'Weekly Report Generator',
  description: 'Generates a weekly project status report from task data.',
  industry: 'custom',
  tags: ['reporting', 'project-management'],
  inputSchema: {
    type: 'object',
    properties: {
      projectName: { type: 'string' },
      tasks: { type: 'array', items: { type: 'object' } },
      period: { type: 'string', format: 'date' },
    },
    required: ['projectName', 'tasks'],
  },
  steps: [
    {
      id: 'categorize',
      prompt: 'Categorize tasks by status and priority: {{input.tasks}}',
      model: 'haiku',
    },
    {
      id: 'summarize',
      prompt: 'Write a status summary for {{input.projectName}}: {{categorize.output}}',
      model: 'sonnet',
      dependsOn: ['categorize'],
    },
    {
      id: 'format',
      prompt: 'Format as a professional weekly report with charts data: {{summarize.output}}',
      model: 'sonnet',
      dependsOn: ['summarize'],
    },
  ],
});
 
console.log('Template published:', template.id);