Agent Session API

function createAgentSession(args?: CreateSessionArgs): Promise<AgentSession>

import { createAgentSession } from 'agentary-js';
 
const agent = await createAgentSession({
  models: [
    {
      runtime: 'transformers-js',
      model: 'onnx-community/Qwen3-0.6B-ONNX',
      quantization: 'q4',
      engine: 'webgpu'
    }
  ]
});

runWorkflow(
  prompt: string,
  workflow: Workflow,
  memoryConfig?: MemoryConfig
): AsyncIterable<WorkflowIterationResponse>

interface Workflow {
  id: string;
  systemPrompt?: string;
  context?: Record<string, any>;
  steps: WorkflowStep[];
  tools: Tool[];
  timeout?: number;
  maxIterations?: number;
}
 
interface WorkflowStep {
  id: string;
  prompt: string;
  model: string;           // Model to use for this step
  maxTokens?: number;
  temperature?: number;
  enableThinking?: boolean;
  toolChoice?: string[];   // Restrict to specific tools
  maxAttempts?: number;    // Retry attempts on failure
}

interface WorkflowIterationResponse {
  stepId?: string;
  error?: WorkflowStepError;
  content?: string;
  toolCall?: {
    name?: string;
    args?: Record<string, any>;
    result?: string;
  };
  metadata?: Record<string, any>;
}

const workflow = {
  id: 'my-workflow',
  systemPrompt: 'You are a helpful assistant.',
  maxIterations: 5,
  steps: [
    {
      id: 'step1',
      prompt: 'Analyze the input',
      model: 'onnx-community/Qwen3-0.6B-ONNX',
      maxTokens: 200
    }
  ],
  tools: []
};
 
const memoryConfig = {
  maxTokens: 2048,
  compressionThreshold: 0.8,
  memoryCompressorConfig: {
    name: 'sliding-window'
  }
};
 
for await (const iteration of agent.runWorkflow('Hello', workflow, memoryConfig)) {
  console.log(iteration.content);
}

registerTools(tools: Tool[]): void

agent.registerTools([{
  definition: {
    name: 'my_tool',
    description: 'Does something useful',
    parameters: {
      type: 'object',
      properties: {
        input: { 
          type: 'string',
          description: 'Input to process'
        }
      },
      required: ['input']
    }
  },
  implementation: async ({ input }) => {
    return `Processed: ${input}`;
  }
}]);

getRegisteredTools(): Tool[]

const tools = agent.getRegisteredTools();
console.log(`${tools.length} tools registered`);

interface MemoryConfig {
  maxTokens?: number;
  compressionThreshold?: number;
  preserveMessageTypes?: MemoryMessageType[];
  formatter?: MemoryFormatter;
  memoryCompressorConfig?: MemoryCompressorConfig;
}
 
type MemoryCompressorConfig = 
  | { name: 'sliding-window' }
  | { 
      name: 'summarization';
      model: string;
      temperature?: number;
      enableThinking?: boolean;
    };

const memoryConfig = {
  maxTokens: 2048,
  compressionThreshold: 0.8,
  memoryCompressorConfig: {
    name: 'sliding-window'
  }
};
 
for await (const result of agent.runWorkflow(prompt, workflow, memoryConfig)) {
  // ...
}

const memoryConfig = {
  maxTokens: 4096,
  compressionThreshold: 0.75,
  memoryCompressorConfig: {
    name: 'summarization',
    model: 'onnx-community/Qwen3-0.6B-ONNX',
    temperature: 0.1,
    enableThinking: false
  }
};
 
for await (const result of agent.runWorkflow(prompt, workflow, memoryConfig)) {
  // ...
}

agent.on('workflow:start', (event) => {
  console.log(`Starting: ${event.workflowName}`);
});
 
agent.on('workflow:step:start', (event) => {
  console.log(`Step ${event.stepId} starting`);
});
 
agent.on('workflow:step:complete', (event) => {
  console.log(`Step ${event.stepId} complete`);
});
 
agent.on('workflow:complete', (event) => {
  console.log(`Workflow complete in ${event.duration}ms`);
});
 
agent.on('workflow:error', (event) => {
  console.error(`Workflow failed: ${event.error}`);
});