@intella/sdk 0.0.1

package/src/agents/base-agent.ts

@@ -0,0 +1,166 @@
+import { generateText, streamText, type LanguageModel, type ModelMessage } from 'ai';
+import type { AgentType, AgentConfig, TaskRequest, TaskResponse, StreamChunk, IAgent, MessageContent } from '../types.js';
+
+/**
+ * Abstract base class for all agents
+ * Provides common functionality using AI SDK v6
+ */
+export abstract class BaseAgent implements IAgent {
+  protected config: AgentConfig;
+  public readonly type: AgentType;
+
+  constructor(type: AgentType, config: AgentConfig = {}) {
+    this.type = type;
+    this.config = { ...config };
+  }
+
+  /**
+   * Get the language model instance
+   * Must be implemented by subclasses
+   */
+  abstract getModel(): LanguageModel | Promise<LanguageModel>;
+
+  /**
+   * Execute a task and return the response
+   */
+  async execute(request: TaskRequest): Promise<TaskResponse> {
+    const model = await Promise.resolve(this.getModel());
+    const messages = this.buildMessages(request);
+
+    const result = await generateText({
+      model,
+      messages,
+      temperature: request.temperature ?? this.config.temperature,
+      maxOutputTokens: request.maxTokens ?? this.config.maxTokens,
+    });
+
+    return {
+      text: result.text,
+      agentType: this.type,
+      metadata: {
+        usage: result.usage,
+        finishReason: result.finishReason,
+      },
+    };
+  }
+
+  /**
+   * Stream a task execution
+   */
+  async *stream(request: TaskRequest): AsyncIterable<StreamChunk> {
+    const model = await Promise.resolve(this.getModel());
+    const messages = this.buildMessages(request);
+
+    const result = streamText({
+      model,
+      messages,
+      temperature: request.temperature ?? this.config.temperature,
+      maxOutputTokens: request.maxTokens ?? this.config.maxTokens,
+    });
+
+    let fullText = '';
+    for await (const chunk of result.textStream) {
+      fullText += chunk;
+      yield {
+        text: chunk,
+        agentType: this.type,
+        isDone: false,
+      };
+    }
+
+    // Final chunk to indicate completion
+    yield {
+      text: '',
+      agentType: this.type,
+      isDone: true,
+    };
+  }
+
+  /**
+   * Configure the agent
+   */
+  configure(config: AgentConfig): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): AgentConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Convert TaskRequest content to AI SDK ModelMessage content format
+   */
+  private convertContent(content: MessageContent): string | Array<{ type: 'text'; text: string } | { type: 'file'; data: string | Uint8Array | ArrayBuffer | Buffer | URL; filename?: string; mediaType: string }> {
+    // If content is a string, return as-is
+    if (typeof content === 'string') {
+      return content;
+    }
+
+    // If content is an array, convert to AI SDK format
+    return content.map(part => {
+      if (part.type === 'text') {
+        return {
+          type: 'text' as const,
+          text: part.text,
+        };
+      } else if (part.type === 'file') {
+        return {
+          type: 'file' as const,
+          data: part.data,
+          filename: part.filename,
+          mediaType: part.mediaType,
+        };
+      }
+      // Fallback for unknown types
+      return {
+        type: 'text' as const,
+        text: String(part),
+      };
+    });
+  }
+
+  /**
+   * Build messages array from request
+   */
+  protected buildMessages(request: TaskRequest): ModelMessage[] {
+    const messages: ModelMessage[] = [];
+
+    // Add system prompt if provided
+    if (request.systemPrompt) {
+      messages.push({
+        role: 'system',
+        content: request.systemPrompt,
+      });
+    }
+
+    // Add previous messages if provided
+    if (request.messages && request.messages.length > 0) {
+      for (const msg of request.messages) {
+        // Skip system messages in the messages array (they're handled separately)
+        if (msg.role === 'system') {
+          continue;
+        }
+
+        messages.push({
+          role: msg.role,
+          content: this.convertContent(msg.content),
+        });
+      }
+    }
+
+    // Add the main prompt as user message (only if not empty)
+    // If prompt is empty, the message is likely already in the messages array
+    if (request.prompt && request.prompt.trim()) {
+      messages.push({
+        role: 'user',
+        content: request.prompt,
+      });
+    }
+
+    return messages;
+  }
+}
+

package/src/agents/claude-agent.ts

@@ -0,0 +1,77 @@
+import { BaseAgent } from './base-agent.js';
+import type { AgentConfig } from '../types.js';
+import type { LanguageModel } from 'ai';
+
+import { claudeCode, createClaudeCode, McpServerConfig } from 'ai-sdk-provider-claude-code';
+
+
+/**
+ * Claude Agent
+ * Powered by Claude Code provider
+ */
+export class ClaudeAgent extends BaseAgent {
+  private modelInstance: LanguageModel | null = null;
+
+  constructor(config: AgentConfig = {}) {
+    super('claude', config);
+  }
+
+  /**
+   * Get or create the language model instance
+   * 
+   * Supports Claude Code provider options:
+   * - allowedTools, disallowedTools, mcpServers, permissionMode, maxTurns, cwd, verbose
+   * See: https://ai-sdk.dev/providers/community-providers/claude-code
+   */
+  async getModel(): Promise<LanguageModel> {
+    if (!this.modelInstance) {
+      // Dynamic import to handle optional peer dependency
+
+      // Claude Code provider takes model ID as string parameter
+      // Uses CLI authentication (claude login) - API key not needed in code
+      // Model shortcuts: 'opus', 'sonnet', 'haiku'
+      const modelId = this.config.model || 'sonnet';
+
+      // Check if custom provider options are provided
+      const hasCustomOptions =
+        this.config.allowedTools ||
+        this.config.disallowedTools ||
+        this.config.mcpServers ||
+        this.config.permissionMode ||
+        this.config.maxTurns ||
+        this.config.cwd !== undefined ||
+        this.config.verbose !== undefined;
+
+      if (hasCustomOptions) {
+        // Create custom provider instance with options
+        const customProvider = createClaudeCode({
+          defaultSettings: {
+            allowedTools: this.config.allowedTools as string[] | undefined,
+            disallowedTools: this.config.disallowedTools as string[] | undefined,
+            mcpServers: this.config.mcpServers as Record<string, McpServerConfig> | undefined,
+            permissionMode: this.config.permissionMode as 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | undefined,
+            maxTurns: this.config.maxTurns as number | undefined,
+            cwd: this.config.cwd as string | undefined,
+            verbose: this.config.verbose as boolean | undefined,
+          }
+        });
+        this.modelInstance = customProvider(modelId);
+      } else {
+        // Use default provider instance
+        this.modelInstance = claudeCode(modelId);
+      }
+    }
+
+    return this.modelInstance;
+  }
+
+  /**
+   * Override configure to reset model instance when config changes
+   */
+  configure(config: AgentConfig): void {
+    super.configure(config);
+    // Reset model instance so it's recreated with new config
+    this.modelInstance = null;
+  }
+}
+

package/src/agents/codex-agent.ts

@@ -0,0 +1,72 @@
+import { BaseAgent } from './base-agent.js';
+import type { AgentConfig } from '../types.js';
+import type { LanguageModel } from 'ai';
+
+/**
+ * Codex Agent
+ * Powered by Codex CLI provider
+ */
+export class CodexAgent extends BaseAgent {
+  private modelInstance: LanguageModel | null = null;
+
+  constructor(config: AgentConfig = {}) {
+    super('codex', config);
+  }
+
+  /**
+   * Get or create the language model instance
+   * 
+   * Supports Codex CLI provider options:
+   * - reasoningEffort, approvalMode, sandboxMode, mcpServers, verbose, logger
+   * - Can use OPENAI_API_KEY environment variable for authentication
+   * See: https://ai-sdk.dev/providers/community-providers/codex-cli
+   */
+  async getModel(): Promise<LanguageModel> {
+    if (!this.modelInstance) {
+      // Dynamic import to handle optional peer dependency
+      const { codexCli } = await import('ai-sdk-provider-codex-cli');
+      
+      // Codex CLI provider takes model ID as string parameter
+      // Uses CLI authentication or OPENAI_API_KEY env var
+      // Current models: 'gpt-5.2-codex', 'gpt-5.2', 'gpt-5.1-codex-max', 'gpt-5.1-codex-mini'
+      const modelId = this.config.model || 'gpt-5.2-codex';
+      
+      // Check if per-model settings are provided
+      const hasModelSettings =
+        this.config.reasoningEffort !== undefined ||
+        this.config.approvalMode !== undefined ||
+        this.config.sandboxMode !== undefined ||
+        this.config.mcpServers !== undefined ||
+        this.config.verbose !== undefined ||
+        this.config.logger !== undefined;
+
+      if (hasModelSettings) {
+        // Pass settings as second parameter
+        // Using type assertion for flexibility with provider-specific types
+        this.modelInstance = codexCli(modelId, {
+          reasoningEffort: this.config.reasoningEffort as 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | undefined,
+          approvalMode: this.config.approvalMode as 'untrusted' | 'on-failure' | 'on-request' | 'never' | undefined,
+          sandboxMode: this.config.sandboxMode as 'read-only' | 'workspace-write' | 'danger-full-access' | undefined,
+          mcpServers: this.config.mcpServers as any,
+          verbose: this.config.verbose as boolean | undefined,
+          logger: this.config.logger as any,
+        } as any);
+      } else {
+        // Create model instance without additional settings
+        this.modelInstance = codexCli(modelId);
+      }
+    }
+
+    return this.modelInstance;
+  }
+
+  /**
+   * Override configure to reset model instance when config changes
+   */
+  configure(config: AgentConfig): void {
+    super.configure(config);
+    // Reset model instance so it's recreated with new config
+    this.modelInstance = null;
+  }
+}
+

package/src/agents/intella-lite-agent.ts

@@ -0,0 +1,55 @@
+import { createOpenAI } from '@ai-sdk/openai';
+import type { LanguageModel } from 'ai';
+import { BaseAgent } from './base-agent.js';
+import type { AgentConfig } from '../types.js';
+
+/**
+ * Intella Lite Agent
+ * Lightweight default agent using OpenAI-compatible interface
+ * This is a separate implementation from Mielto
+ */
+export class IntellaLiteAgent extends BaseAgent {
+  private modelInstance: LanguageModel | null = null;
+
+  constructor(config: AgentConfig = {}) {
+    super('intella-lite', config);
+  }
+
+  /**
+   * Get or create the language model instance
+   */
+  getModel(): LanguageModel {
+    if (!this.modelInstance) {
+      // Use OpenAI provider as base for Intella Lite
+      // Default to a lightweight model if not specified
+      const modelId = this.config.model || 'gpt-4o-mini';
+      
+      const apiKey = this.config.apiKey || process.env.OPENAI_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          'OpenAI API key is required for Intella Lite agent. Set OPENAI_API_KEY environment variable or provide apiKey in config.'
+        );
+      }
+      
+      const provider = createOpenAI({
+        apiKey,
+        baseURL: this.config.baseURL || process.env.OPENAI_BASE_URL,
+        headers: this.config.headers,
+      });
+
+      this.modelInstance = provider.chat(modelId);
+    }
+
+    return this.modelInstance;
+  }
+
+  /**
+   * Override configure to reset model instance when config changes
+   */
+  configure(config: AgentConfig): void {
+    super.configure(config);
+    // Reset model instance so it's recreated with new config
+    this.modelInstance = null;
+  }
+}
+

package/src/agents/opencode-agent.ts

@@ -0,0 +1,45 @@
+import { BaseAgent } from './base-agent.js';
+import type { AgentConfig } from '../types.js';
+import type { LanguageModel } from 'ai';
+
+/**
+ * OpenCode Agent
+ * Powered by OpenCode SDK provider
+ */
+export class OpenCodeAgent extends BaseAgent {
+  private modelInstance: LanguageModel | null = null;
+
+  constructor(config: AgentConfig = {}) {
+    super('opencode', config);
+  }
+
+  /**
+   * Get or create the language model instance
+   */
+  async getModel(): Promise<LanguageModel> {
+    if (!this.modelInstance) {
+      // Dynamic import to handle optional peer dependency
+      const { opencode } = await import('ai-sdk-provider-opencode-sdk');
+      
+      // OpenCode provider takes model ID as string parameter
+      // Uses CLI authentication (opencode login) - API key not needed in code
+      // Model format: 'provider/model-id' (e.g., 'anthropic/claude-sonnet-4-5-20250929')
+      const modelId = this.config.model || 'anthropic/claude-sonnet-4-5-20250929';
+      
+      // Create model instance directly
+      this.modelInstance = opencode(modelId);
+    }
+
+    return this.modelInstance;
+  }
+
+  /**
+   * Override configure to reset model instance when config changes
+   */
+  configure(config: AgentConfig): void {
+    super.configure(config);
+    // Reset model instance so it's recreated with new config
+    this.modelInstance = null;
+  }
+}
+