@devang0907/agent-dev 0.1.0

package/dist/main.js

@@ -0,0 +1,45 @@
+import { render } from "ink";
+import React from "react";
+import { loadSettings } from "./config/settings.js";
+import { SessionManager } from "./session/manager.js";
+import { AgentSession } from "./agent/session.js";
+import { parseArgs, printHelp } from "./cli/args.js";
+import { runPrintMode } from "./modes/print-mode.js";
+import { App } from "./ui/App.js";
+export async function main() {
+    const args = parseArgs(process.argv);
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    const settings = loadSettings();
+    const workdir = process.cwd();
+    let sessionManager;
+    if (args.continueSession) {
+        sessionManager = SessionManager.loadLast() ?? new SessionManager(undefined, workdir);
+    }
+    else {
+        sessionManager = new SessionManager(undefined, workdir);
+    }
+    const initialModel = AgentSession.resolveInitialModel(settings, args.model);
+    const session = new AgentSession(settings, sessionManager, workdir, initialModel);
+    const usePrint = args.print || !process.stdin.isTTY || !process.stdout.isTTY;
+    if (usePrint) {
+        const prompt = args.prompt ?? "";
+        if (!prompt) {
+            console.error("Print mode requires a prompt argument.");
+            process.exit(1);
+        }
+        await runPrintMode(session, prompt);
+        return;
+    }
+    const { waitUntilExit } = render(React.createElement(App, {
+        session,
+        workdir,
+        onQuit: () => { },
+    }));
+    if (args.prompt) {
+        setTimeout(() => session.prompt(args.prompt), 100);
+    }
+    await waitUntilExit();
+}

package/dist/modes/print-mode.d.ts

@@ -0,0 +1,2 @@
+import type { AgentSession } from "../agent/session.js";
+export declare function runPrintMode(session: AgentSession, prompt: string): Promise<void>;

package/dist/modes/print-mode.js

@@ -0,0 +1,32 @@
+import chalk from "chalk";
+import { runAgentLoop } from "../agent/loop.js";
+export async function runPrintMode(session, prompt) {
+    const model = session.getModel();
+    console.log(chalk.gray(`Model: ${model.provider}/${model.id}`));
+    const userMsg = { role: "user", content: prompt };
+    const prior = session.getMessages();
+    let output = "";
+    await runAgentLoop({
+        model,
+        messages: [...prior, userMsg],
+        settings: session.getSettings(),
+        workdir: process.cwd(),
+        onEvent: (event) => {
+            if (event.type === "text_delta") {
+                process.stdout.write(event.delta);
+                output += event.delta;
+            }
+            else if (event.type === "tool_call") {
+                console.log(chalk.yellow(`\n[tool: ${event.toolCall.name}]`));
+            }
+            else if (event.type === "tool_result") {
+                console.log(chalk.gray(event.result.slice(0, 500)));
+            }
+            else if (event.type === "error") {
+                console.error(chalk.red(event.message));
+            }
+        },
+    });
+    if (!output.endsWith("\n"))
+        console.log();
+}

package/dist/providers/gemini.d.ts

@@ -0,0 +1,10 @@
+import type { ChatContext, Model, StreamEvent } from "./types.js";
+import type { Settings } from "../config/settings.js";
+export declare const PROVIDER_ID: "gemini";
+export declare const DEFAULT_MODEL = "gemini-2.0-flash";
+export declare const API_KEY_ENV = "GEMINI_API_KEY";
+export declare const API_KEY_ENV_ALT = "GOOGLE_API_KEY";
+export declare const MODELS: Model[];
+export declare function getApiKey(settings?: Settings): string | undefined;
+export declare function hasAuth(settings?: Settings): boolean;
+export declare function streamChat(model: Model, ctx: ChatContext, settings?: Settings): AsyncGenerator<StreamEvent>;

package/dist/providers/gemini.js

@@ -0,0 +1,116 @@
+import { GoogleGenAI } from "@google/genai";
+export const PROVIDER_ID = "gemini";
+export const DEFAULT_MODEL = "gemini-2.0-flash";
+export const API_KEY_ENV = "GEMINI_API_KEY";
+export const API_KEY_ENV_ALT = "GOOGLE_API_KEY";
+export const MODELS = [
+    { provider: PROVIDER_ID, id: "gemini-2.0-flash", name: "Gemini 2.0 Flash" },
+    { provider: PROVIDER_ID, id: "gemini-2.5-flash", name: "Gemini 2.5 Flash" },
+];
+export function getApiKey(settings) {
+    return (process.env[API_KEY_ENV] ??
+        process.env[API_KEY_ENV_ALT] ??
+        settings?.apiKeys?.gemini);
+}
+export function hasAuth(settings) {
+    return !!getApiKey(settings);
+}
+function toFunctionDeclarations(tools) {
+    return tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        parametersJsonSchema: t.parameters,
+    }));
+}
+function toGeminiContents(messages) {
+    const contents = [];
+    for (const m of messages) {
+        if (m.role === "user") {
+            contents.push({ role: "user", parts: [{ text: m.content }] });
+        }
+        else if (m.role === "assistant") {
+            const parts = [];
+            if (m.content)
+                parts.push({ text: m.content });
+            if (m.toolCalls) {
+                for (const tc of m.toolCalls) {
+                    parts.push({
+                        functionCall: {
+                            name: tc.name,
+                            args: JSON.parse(tc.arguments || "{}"),
+                        },
+                    });
+                }
+            }
+            if (parts.length > 0)
+                contents.push({ role: "model", parts });
+        }
+        else if (m.role === "tool") {
+            contents.push({
+                role: "user",
+                parts: [{
+                        functionResponse: {
+                            name: m.name ?? "tool",
+                            response: { result: m.content },
+                        },
+                    }],
+            });
+        }
+    }
+    return contents;
+}
+export async function* streamChat(model, ctx, settings) {
+    const apiKey = getApiKey(settings);
+    if (!apiKey) {
+        yield { type: "error", message: `Missing ${API_KEY_ENV} or ${API_KEY_ENV_ALT}` };
+        return;
+    }
+    const ai = new GoogleGenAI({ apiKey });
+    try {
+        const stream = await ai.models.generateContentStream({
+            model: model.id,
+            contents: toGeminiContents(ctx.messages),
+            config: {
+                systemInstruction: ctx.systemPrompt,
+                tools: ctx.tools.length > 0
+                    ? [{ functionDeclarations: toFunctionDeclarations(ctx.tools) }]
+                    : undefined,
+                abortSignal: ctx.signal,
+            },
+        });
+        const toolCalls = new Map();
+        let toolIndex = 0;
+        for await (const chunk of stream) {
+            const parts = chunk.candidates?.[0]?.content?.parts ?? [];
+            for (const part of parts) {
+                if (part.text) {
+                    yield { type: "text_delta", delta: part.text };
+                }
+                if (part.functionCall) {
+                    const fc = part.functionCall;
+                    const idx = toolIndex++;
+                    const args = JSON.stringify(fc.args ?? {});
+                    toolCalls.set(idx, { id: `gemini_${idx}`, name: fc.name ?? "", arguments: args });
+                    yield {
+                        type: "tool_call_delta",
+                        index: idx,
+                        id: `gemini_${idx}`,
+                        name: fc.name,
+                        argumentsDelta: args,
+                    };
+                }
+            }
+            if (chunk.usageMetadata) {
+                // usage available on final chunk
+            }
+        }
+        yield {
+            type: "done",
+            usage: undefined,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        yield { type: "error", message };
+    }
+}

package/dist/providers/groq.d.ts

@@ -0,0 +1,10 @@
+import type { ChatContext, Model, StreamEvent } from "./types.js";
+import type { Settings } from "../config/settings.js";
+export declare const PROVIDER_ID: "groq";
+export declare const DEFAULT_MODEL = "llama-3.3-70b-versatile";
+export declare const API_KEY_ENV = "GROQ_API_KEY";
+export declare const BASE_URL = "https://api.groq.com/openai/v1";
+export declare const MODELS: Model[];
+export declare function getApiKey(settings?: Settings): string | undefined;
+export declare function hasAuth(settings?: Settings): boolean;
+export declare function streamChat(model: Model, ctx: ChatContext, settings?: Settings): AsyncGenerator<StreamEvent>;

package/dist/providers/groq.js

@@ -0,0 +1,113 @@
+import OpenAI from "openai";
+export const PROVIDER_ID = "groq";
+export const DEFAULT_MODEL = "llama-3.3-70b-versatile";
+export const API_KEY_ENV = "GROQ_API_KEY";
+export const BASE_URL = "https://api.groq.com/openai/v1";
+export const MODELS = [
+    { provider: PROVIDER_ID, id: "llama-3.3-70b-versatile", name: "Llama 3.3 70B" },
+    { provider: PROVIDER_ID, id: "openai/gpt-oss-120b", name: "GPT-OSS 120B" },
+];
+export function getApiKey(settings) {
+    return process.env[API_KEY_ENV] ?? settings?.apiKeys?.groq;
+}
+export function hasAuth(settings) {
+    return !!getApiKey(settings);
+}
+function toOpenAIMessages(ctx) {
+    const msgs = [];
+    if (ctx.systemPrompt) {
+        msgs.push({ role: "system", content: ctx.systemPrompt });
+    }
+    for (const m of ctx.messages) {
+        if (m.role === "user") {
+            msgs.push({ role: "user", content: m.content });
+        }
+        else if (m.role === "assistant") {
+            if (m.toolCalls?.length) {
+                msgs.push({
+                    role: "assistant",
+                    content: m.content || null,
+                    tool_calls: m.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    })),
+                });
+            }
+            else {
+                msgs.push({ role: "assistant", content: m.content });
+            }
+        }
+        else if (m.role === "tool") {
+            msgs.push({
+                role: "tool",
+                tool_call_id: m.toolCallId,
+                content: m.content,
+            });
+        }
+    }
+    return msgs;
+}
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+export async function* streamChat(model, ctx, settings) {
+    const apiKey = getApiKey(settings);
+    if (!apiKey) {
+        yield { type: "error", message: `Missing ${API_KEY_ENV}` };
+        return;
+    }
+    const client = new OpenAI({ apiKey, baseURL: BASE_URL });
+    try {
+        const stream = await client.chat.completions.create({
+            model: model.id,
+            messages: toOpenAIMessages(ctx),
+            tools: ctx.tools.length > 0 ? toOpenAITools(ctx.tools) : undefined,
+            stream: true,
+        }, { signal: ctx.signal });
+        const toolCalls = new Map();
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                yield { type: "text_delta", delta: delta.content };
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const idx = tc.index;
+                    if (!toolCalls.has(idx)) {
+                        toolCalls.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: "" });
+                    }
+                    const existing = toolCalls.get(idx);
+                    if (tc.id)
+                        existing.id = tc.id;
+                    if (tc.function?.name)
+                        existing.name = tc.function.name;
+                    if (tc.function?.arguments) {
+                        existing.arguments += tc.function.arguments;
+                        yield {
+                            type: "tool_call_delta",
+                            index: idx,
+                            id: existing.id,
+                            name: existing.name,
+                            argumentsDelta: tc.function.arguments,
+                        };
+                    }
+                }
+            }
+        }
+        yield { type: "done" };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        yield { type: "error", message };
+    }
+}

package/dist/providers/openai.d.ts

@@ -0,0 +1,10 @@
+import type { ChatContext, Model, StreamEvent } from "./types.js";
+import type { Settings } from "../config/settings.js";
+export declare const PROVIDER_ID: "openai";
+export declare const DEFAULT_MODEL = "gpt-4o";
+export declare const API_KEY_ENV = "OPENAI_API_KEY";
+export declare const BASE_URL = "https://api.openai.com/v1";
+export declare const MODELS: Model[];
+export declare function getApiKey(settings?: Settings): string | undefined;
+export declare function hasAuth(settings?: Settings): boolean;
+export declare function streamChat(model: Model, ctx: ChatContext, settings?: Settings): AsyncGenerator<StreamEvent>;

package/dist/providers/openai.js

@@ -0,0 +1,121 @@
+import OpenAI from "openai";
+export const PROVIDER_ID = "openai";
+export const DEFAULT_MODEL = "gpt-4o";
+export const API_KEY_ENV = "OPENAI_API_KEY";
+export const BASE_URL = "https://api.openai.com/v1";
+export const MODELS = [
+    { provider: PROVIDER_ID, id: "gpt-4o", name: "GPT-4o" },
+    { provider: PROVIDER_ID, id: "gpt-4o-mini", name: "GPT-4o Mini" },
+];
+export function getApiKey(settings) {
+    return process.env[API_KEY_ENV] ?? settings?.apiKeys?.openai;
+}
+export function hasAuth(settings) {
+    return !!getApiKey(settings);
+}
+function toOpenAIMessages(ctx) {
+    const msgs = [];
+    if (ctx.systemPrompt) {
+        msgs.push({ role: "system", content: ctx.systemPrompt });
+    }
+    for (const m of ctx.messages) {
+        if (m.role === "user") {
+            msgs.push({ role: "user", content: m.content });
+        }
+        else if (m.role === "assistant") {
+            if (m.toolCalls?.length) {
+                msgs.push({
+                    role: "assistant",
+                    content: m.content || null,
+                    tool_calls: m.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    })),
+                });
+            }
+            else {
+                msgs.push({ role: "assistant", content: m.content });
+            }
+        }
+        else if (m.role === "tool") {
+            msgs.push({
+                role: "tool",
+                tool_call_id: m.toolCallId,
+                content: m.content,
+            });
+        }
+    }
+    return msgs;
+}
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+export async function* streamChat(model, ctx, settings) {
+    const apiKey = getApiKey(settings);
+    if (!apiKey) {
+        yield { type: "error", message: `Missing ${API_KEY_ENV}` };
+        return;
+    }
+    const client = new OpenAI({ apiKey, baseURL: BASE_URL });
+    try {
+        const stream = await client.chat.completions.create({
+            model: model.id,
+            messages: toOpenAIMessages(ctx),
+            tools: ctx.tools.length > 0 ? toOpenAITools(ctx.tools) : undefined,
+            stream: true,
+            stream_options: { include_usage: true },
+        }, { signal: ctx.signal });
+        const toolCalls = new Map();
+        let usage;
+        for await (const chunk of stream) {
+            if (chunk.usage) {
+                usage = {
+                    inputTokens: chunk.usage.prompt_tokens,
+                    outputTokens: chunk.usage.completion_tokens,
+                };
+            }
+            const delta = chunk.choices[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                yield { type: "text_delta", delta: delta.content };
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const idx = tc.index;
+                    if (!toolCalls.has(idx)) {
+                        toolCalls.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: "" });
+                    }
+                    const existing = toolCalls.get(idx);
+                    if (tc.id)
+                        existing.id = tc.id;
+                    if (tc.function?.name)
+                        existing.name = tc.function.name;
+                    if (tc.function?.arguments) {
+                        existing.arguments += tc.function.arguments;
+                        yield {
+                            type: "tool_call_delta",
+                            index: idx,
+                            id: existing.id,
+                            name: existing.name,
+                            argumentsDelta: tc.function.arguments,
+                        };
+                    }
+                }
+            }
+        }
+        yield { type: "done", usage };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        yield { type: "error", message };
+    }
+}

package/dist/providers/openrouter-free.d.ts

@@ -0,0 +1,10 @@
+import type { ChatContext, Model, StreamEvent } from "./types.js";
+import type { Settings } from "../config/settings.js";
+export declare const PROVIDER_ID: "free";
+export declare const DEFAULT_MODEL = "meta-llama/llama-3.3-70b-instruct:free";
+export declare const API_KEY_ENV = "OPENROUTER_API_KEY";
+export declare const BASE_URL = "https://openrouter.ai/api/v1";
+export declare const MODELS: Model[];
+export declare function getApiKey(settings?: Settings): string | undefined;
+export declare function hasAuth(settings?: Settings): boolean;
+export declare function streamChat(model: Model, ctx: ChatContext, settings?: Settings): AsyncGenerator<StreamEvent>;

package/dist/providers/openrouter-free.js

@@ -0,0 +1,133 @@
+import OpenAI from "openai";
+export const PROVIDER_ID = "free";
+export const DEFAULT_MODEL = "meta-llama/llama-3.3-70b-instruct:free";
+export const API_KEY_ENV = "OPENROUTER_API_KEY";
+export const BASE_URL = "https://openrouter.ai/api/v1";
+export const MODELS = [
+    {
+        provider: PROVIDER_ID,
+        id: "meta-llama/llama-3.3-70b-instruct:free",
+        name: "Llama 3.3 70B (free)",
+    },
+    {
+        provider: PROVIDER_ID,
+        id: "google/gemini-2.0-flash-exp:free",
+        name: "Gemini 2.0 Flash (free)",
+    },
+    {
+        provider: PROVIDER_ID,
+        id: "qwen/qwen-2.5-72b-instruct:free",
+        name: "Qwen 2.5 72B (free)",
+    },
+];
+export function getApiKey(settings) {
+    return process.env[API_KEY_ENV] ?? settings?.apiKeys?.free;
+}
+export function hasAuth(settings) {
+    return !!getApiKey(settings);
+}
+function toOpenAIMessages(ctx) {
+    const msgs = [];
+    if (ctx.systemPrompt) {
+        msgs.push({ role: "system", content: ctx.systemPrompt });
+    }
+    for (const m of ctx.messages) {
+        if (m.role === "user") {
+            msgs.push({ role: "user", content: m.content });
+        }
+        else if (m.role === "assistant") {
+            if (m.toolCalls?.length) {
+                msgs.push({
+                    role: "assistant",
+                    content: m.content || null,
+                    tool_calls: m.toolCalls.map((tc) => ({
+                        id: tc.id,
+                        type: "function",
+                        function: { name: tc.name, arguments: tc.arguments },
+                    })),
+                });
+            }
+            else {
+                msgs.push({ role: "assistant", content: m.content });
+            }
+        }
+        else if (m.role === "tool") {
+            msgs.push({
+                role: "tool",
+                tool_call_id: m.toolCallId,
+                content: m.content,
+            });
+        }
+    }
+    return msgs;
+}
+function toOpenAITools(tools) {
+    return tools.map((t) => ({
+        type: "function",
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+        },
+    }));
+}
+export async function* streamChat(model, ctx, settings) {
+    const apiKey = getApiKey(settings);
+    if (!apiKey) {
+        yield { type: "error", message: `Missing ${API_KEY_ENV}` };
+        return;
+    }
+    const client = new OpenAI({
+        apiKey,
+        baseURL: BASE_URL,
+        defaultHeaders: {
+            "HTTP-Referer": "https://github.com/agent-dev",
+            "X-Title": "agent-dev",
+        },
+    });
+    try {
+        const stream = await client.chat.completions.create({
+            model: model.id,
+            messages: toOpenAIMessages(ctx),
+            tools: ctx.tools.length > 0 ? toOpenAITools(ctx.tools) : undefined,
+            stream: true,
+        }, { signal: ctx.signal });
+        const toolCalls = new Map();
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                yield { type: "text_delta", delta: delta.content };
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    const idx = tc.index;
+                    if (!toolCalls.has(idx)) {
+                        toolCalls.set(idx, { id: tc.id ?? "", name: tc.function?.name ?? "", arguments: "" });
+                    }
+                    const existing = toolCalls.get(idx);
+                    if (tc.id)
+                        existing.id = tc.id;
+                    if (tc.function?.name)
+                        existing.name = tc.function.name;
+                    if (tc.function?.arguments) {
+                        existing.arguments += tc.function.arguments;
+                        yield {
+                            type: "tool_call_delta",
+                            index: idx,
+                            id: existing.id,
+                            name: existing.name,
+                            argumentsDelta: tc.function.arguments,
+                        };
+                    }
+                }
+            }
+        }
+        yield { type: "done" };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        yield { type: "error", message };
+    }
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,7 @@
+import type { ChatContext, Model, ProviderId, StreamEvent } from "./types.js";
+import type { Settings } from "../config/settings.js";
+export declare function hasProviderAuth(provider: ProviderId, settings?: Settings): boolean;
+export declare function getAvailableModels(settings?: Settings): Model[];
+export declare function streamChat(model: Model, ctx: ChatContext, settings?: Settings): AsyncGenerator<StreamEvent>;
+export declare function getDefaultModelForProvider(provider: ProviderId): Model | undefined;
+export declare const PROVIDER_ENV_VARS: Record<ProviderId, string[]>;

package/dist/providers/registry.js

@@ -0,0 +1,39 @@
+import * as openai from "./openai.js";
+import * as groq from "./groq.js";
+import * as gemini from "./gemini.js";
+import * as openrouterFree from "./openrouter-free.js";
+import { ALL_MODELS } from "../config/models.js";
+const PROVIDERS = {
+    openai: openai,
+    groq: groq,
+    gemini: gemini,
+    free: openrouterFree,
+};
+export function hasProviderAuth(provider, settings) {
+    return PROVIDERS[provider].hasAuth(settings);
+}
+export function getAvailableModels(settings) {
+    return ALL_MODELS.filter((m) => hasProviderAuth(m.provider, settings));
+}
+export function streamChat(model, ctx, settings) {
+    const provider = PROVIDERS[model.provider];
+    return provider.streamChat(model, ctx, settings);
+}
+export function getDefaultModelForProvider(provider) {
+    switch (provider) {
+        case "openai":
+            return openai.MODELS[0];
+        case "groq":
+            return groq.MODELS[0];
+        case "gemini":
+            return gemini.MODELS[0];
+        case "free":
+            return openrouterFree.MODELS[0];
+    }
+}
+export const PROVIDER_ENV_VARS = {
+    openai: [openai.API_KEY_ENV],
+    groq: [groq.API_KEY_ENV],
+    gemini: [gemini.API_KEY_ENV, gemini.API_KEY_ENV_ALT],
+    free: [openrouterFree.API_KEY_ENV],
+};