tg-agent 0.1.0

package/dist/piAgentRunner.js

@@ -0,0 +1,407 @@
+import { createAgentSession, discoverAuthStorage, discoverModels, SessionManager, SettingsManager, } from "@mariozechner/pi-coding-agent";
+import { config } from "./config.js";
+import { readCodexOAuth } from "./codexAuth.js";
+import { createCustomTools } from "./customTools.js";
+import { ensureDir } from "./utils.js";
+import { sessionFilePath } from "./sessionStore.js";
+const CODEX_MODEL_ALIASES = {
+    "codex-mini-latest": "gpt-5.1-codex-mini",
+    "codex-max-latest": "gpt-5.1-codex-max",
+    "codex-latest": "gpt-5.2-codex",
+};
+function normalizeProviderId(provider) {
+    const trimmed = provider.trim().toLowerCase();
+    if (trimmed === "codex")
+        return "openai-codex";
+    return trimmed;
+}
+function splitModelRef(ref, fallbackProvider) {
+    const trimmed = ref.trim();
+    if (!trimmed) {
+        return { provider: fallbackProvider, modelId: "" };
+    }
+    if (trimmed.includes("/")) {
+        const [provider, modelId] = trimmed.split("/", 2);
+        return { provider: provider.trim() || fallbackProvider, modelId: modelId.trim() };
+    }
+    return { provider: fallbackProvider, modelId: trimmed };
+}
+function normalizeModelId(provider, modelId) {
+    if (provider !== "openai-codex") {
+        return modelId;
+    }
+    const mapped = CODEX_MODEL_ALIASES[modelId];
+    return mapped ?? modelId;
+}
+function pickDefaultModel(modelRegistry, provider) {
+    const available = modelRegistry.getAvailable().filter((model) => model.provider === provider);
+    if (available.length > 0) {
+        return available[0];
+    }
+    const allModels = modelRegistry.getAll().filter((model) => model.provider === provider);
+    return allModels[0];
+}
+function resolveModel(modelRegistry, overrides) {
+    const hasOverrideProvider = Boolean(overrides?.provider?.trim());
+    const hasOverrideModel = Boolean(overrides?.modelId?.trim());
+    const providerRaw = normalizeProviderId(overrides?.provider || config.modelProvider || "openai-codex");
+    const modelRef = hasOverrideProvider || hasOverrideModel ? "" : config.modelRef || "";
+    const { provider: refProvider, modelId: refModelId } = splitModelRef(modelRef, providerRaw);
+    const provider = overrides?.provider ? providerRaw : normalizeProviderId(refProvider);
+    let modelId = hasOverrideModel ? overrides?.modelId?.trim() || "" : refModelId;
+    if (!modelId) {
+        const pick = pickDefaultModel(modelRegistry, provider);
+        if (pick) {
+            return { model: pick, provider, modelId: pick.id };
+        }
+        return { model: undefined, provider, modelId: "" };
+    }
+    const normalizedModelId = normalizeModelId(provider, modelId);
+    const model = modelRegistry.find(provider, normalizedModelId);
+    return { model, provider, modelId: normalizedModelId };
+}
+function applyCodexOAuth(authStorage) {
+    const codex = readCodexOAuth();
+    if (!codex) {
+        return null;
+    }
+    authStorage.setRuntimeApiKey("openai-codex", codex.accessToken);
+    return { source: codex.source, expiresAt: codex.expiresAt };
+}
+function extractTextFromMessage(message) {
+    const role = message?.role;
+    if (role !== "assistant")
+        return "";
+    const content = message.content;
+    if (typeof content === "string") {
+        return content.trim();
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const textBlocks = content
+        .filter((block) => typeof block === "object" && block && block.type === "text")
+        .map((block) => block.text ?? "")
+        .map((text) => text.trim())
+        .filter(Boolean);
+    if (textBlocks.length > 0) {
+        return textBlocks.join("\n\n");
+    }
+    const thinkingBlocks = content
+        .filter((block) => typeof block === "object" && block && block.type === "thinking")
+        .map((block) => block.thinking ?? "")
+        .map((text) => text.trim())
+        .filter(Boolean);
+    if (thinkingBlocks.length > 0) {
+        return thinkingBlocks.join("\n\n");
+    }
+    return "";
+}
+function summarizeMessages(messages) {
+    if (messages.length === 0) {
+        return "messages=0";
+    }
+    const tail = messages.slice(-6).map((message) => {
+        const role = message?.role ?? "unknown";
+        const content = message.content;
+        const stopReason = message?.stopReason;
+        const errorMessage = message?.errorMessage;
+        if (typeof content === "string") {
+            return `${role}(text:${content.length}${stopReason ? `,stop=${stopReason}` : ""})`;
+        }
+        if (Array.isArray(content)) {
+            const types = content
+                .map((block) => {
+                if (typeof block === "object" && block && "type" in block) {
+                    return String(block.type || "unknown");
+                }
+                return typeof block;
+            })
+                .join(",");
+            const meta = [
+                `blocks:${types || "none"}`,
+                stopReason ? `stop=${stopReason}` : null,
+                errorMessage ? "error=1" : null,
+            ]
+                .filter(Boolean)
+                .join(",");
+            return `${role}(${meta})`;
+        }
+        if (content == null) {
+            const meta = [
+                "empty",
+                stopReason ? `stop=${stopReason}` : null,
+                errorMessage ? "error=1" : null,
+            ]
+                .filter(Boolean)
+                .join(",");
+            return `${role}(${meta})`;
+        }
+        return `${role}(${typeof content}${stopReason ? `,stop=${stopReason}` : ""})`;
+    });
+    return `messages=${messages.length} last=[${tail.join(" ")}]`;
+}
+function extractAssistantText(messages, session) {
+    const lastText = session?.getLastAssistantText?.();
+    if (lastText?.trim()) {
+        return lastText.trim();
+    }
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const text = extractTextFromMessage(messages[i]);
+        if (text) {
+            return text;
+        }
+    }
+    return "";
+}
+function findLastAssistantMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const role = messages[i]?.role;
+        if (role === "assistant") {
+            return messages[i];
+        }
+    }
+    return undefined;
+}
+export async function runPiAgentPrompt(params) {
+    await ensureDir(config.sessionDir);
+    await ensureDir(config.agentDir);
+    await ensureDir(config.workspaceDir);
+    const sessionFile = sessionFilePath(params.userId, params.sessionId);
+    const authStorage = discoverAuthStorage(config.agentDir);
+    const codexInfo = applyCodexOAuth(authStorage);
+    if (codexInfo) {
+        console.log(`[tg-agent] codex oauth source=${codexInfo.source} expiresAt=${new Date(codexInfo.expiresAt).toISOString()}`);
+    }
+    const modelRegistry = discoverModels(authStorage, config.agentDir);
+    const { model, provider, modelId } = resolveModel(modelRegistry, {
+        provider: params.modelProvider,
+        modelId: params.modelId,
+    });
+    if (modelId && !model) {
+        console.warn(`[tg-agent] model not found: ${provider}/${modelId}`);
+    }
+    const sessionManager = SessionManager.open(sessionFile);
+    const settingsManager = SettingsManager.create(config.workspaceDir, config.agentDir);
+    const { session, modelFallbackMessage } = await createAgentSession({
+        cwd: config.workspaceDir,
+        agentDir: config.agentDir,
+        authStorage,
+        modelRegistry,
+        model: model ?? undefined,
+        sessionManager,
+        settingsManager,
+        customTools: createCustomTools(),
+        systemPrompt: (defaultPrompt) => {
+            const extra = params.systemPrompt?.trim();
+            if (!extra)
+                return defaultPrompt;
+            return `${defaultPrompt}\n\n${extra}`;
+        },
+    });
+    if (modelFallbackMessage) {
+        console.warn(`[tg-agent] modelFallback=${modelFallbackMessage}`);
+    }
+    let userAbortRequested = false;
+    const abortFn = () => {
+        userAbortRequested = true;
+        void session.abort();
+    };
+    params.onAbortReady?.(abortFn);
+    const logEvents = process.env.LOG_AGENT_EVENTS !== "0";
+    const logStream = process.env.LOG_AGENT_STREAM === "1";
+    const toolStartTimes = new Map();
+    const unsubscribe = session.subscribe((event) => {
+        switch (event.type) {
+            case "agent_start":
+                if (logEvents) {
+                    console.log(`[tg-agent] agent start session=${params.sessionId}`);
+                }
+                lastProgressAt = Date.now();
+                params.onStatus?.({ type: "agent_start" });
+                break;
+            case "agent_end":
+                if (logEvents) {
+                    console.log(`[tg-agent] agent end session=${params.sessionId}`);
+                }
+                params.onStatus?.({ type: "agent_end" });
+                break;
+            case "turn_start":
+                if (logEvents) {
+                    console.log(`[tg-agent] turn start session=${params.sessionId}`);
+                }
+                lastProgressAt = Date.now();
+                params.onStatus?.({ type: "turn_start" });
+                break;
+            case "turn_end":
+                if (logEvents) {
+                    console.log(`[tg-agent] turn end session=${params.sessionId} toolResults=${event.toolResults.length}`);
+                }
+                lastProgressAt = Date.now();
+                params.onStatus?.({ type: "turn_end", toolResults: event.toolResults.length });
+                break;
+            case "message_start": {
+                if (logEvents) {
+                    const role = event.message.role ?? "unknown";
+                    console.log(`[tg-agent] message start session=${params.sessionId} role=${role}`);
+                }
+                lastProgressAt = Date.now();
+                {
+                    const role = event.message.role ?? "unknown";
+                    params.onStatus?.({ type: "message_start", role });
+                }
+                break;
+            }
+            case "message_end": {
+                if (logEvents) {
+                    const role = event.message.role ?? "unknown";
+                    console.log(`[tg-agent] message end session=${params.sessionId} role=${role}`);
+                }
+                lastProgressAt = Date.now();
+                {
+                    const role = event.message.role ?? "unknown";
+                    params.onStatus?.({ type: "message_end", role });
+                }
+                break;
+            }
+            case "message_update": {
+                if (!logStream)
+                    break;
+                if (event.assistantMessageEvent.type === "text_delta") {
+                    const delta = event.assistantMessageEvent.delta ?? "";
+                    const len = delta.length;
+                    if (len > 0) {
+                        console.log(`[tg-agent] stream delta session=${params.sessionId} chars=${len}`);
+                    }
+                    lastProgressAt = Date.now();
+                }
+                if (event.assistantMessageEvent.type === "thinking_delta") {
+                    lastProgressAt = Date.now();
+                }
+                break;
+            }
+            case "tool_execution_start": {
+                toolStartTimes.set(event.toolCallId, Date.now());
+                console.log(`[tg-agent] tool start name=${event.toolName} id=${event.toolCallId}`);
+                activeToolCount += 1;
+                lastProgressAt = Date.now();
+                params.onStatus?.({
+                    type: "tool_start",
+                    name: event.toolName,
+                    id: event.toolCallId,
+                    args: event.args,
+                });
+                break;
+            }
+            case "tool_execution_end": {
+                const startedAt = toolStartTimes.get(event.toolCallId);
+                const duration = startedAt ? Date.now() - startedAt : 0;
+                console.log(`[tg-agent] tool end name=${event.toolName} id=${event.toolCallId} ok=${!event.isError} durationMs=${duration}`);
+                toolStartTimes.delete(event.toolCallId);
+                activeToolCount = Math.max(0, activeToolCount - 1);
+                lastProgressAt = Date.now();
+                params.onStatus?.({
+                    type: "tool_end",
+                    name: event.toolName,
+                    id: event.toolCallId,
+                    ok: !event.isError,
+                    durationMs: duration,
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    });
+    let heartbeat = null;
+    let timeoutInterval = null;
+    let timedOut = false;
+    let timedOutAfterMs = 0;
+    let timedOutStreaming = false;
+    let lastProgressAt = Date.now();
+    let activeToolCount = 0;
+    try {
+        const promptStartedAt = Date.now();
+        heartbeat = setInterval(() => {
+            const elapsed = Date.now() - promptStartedAt;
+            console.log(`[tg-agent] prompt running session=${params.sessionId} elapsedMs=${elapsed} streaming=${session.isStreaming}`);
+            params.onStatus?.({
+                type: "heartbeat",
+                elapsedMs: elapsed,
+                streaming: session.isStreaming,
+            });
+        }, 15000);
+        timeoutInterval = setInterval(() => {
+            if (timedOut)
+                return;
+            if (activeToolCount > 0)
+                return;
+            const elapsed = Date.now() - lastProgressAt;
+            const baseTimeout = session.isStreaming
+                ? config.modelTimeoutStreamingMs
+                : config.modelTimeoutMs;
+            const timeoutMs = Math.max(1_000, baseTimeout);
+            if (elapsed >= timeoutMs) {
+                timedOut = true;
+                timedOutAfterMs = timeoutMs;
+                timedOutStreaming = session.isStreaming;
+                console.warn(`[tg-agent] model timeout session=${params.sessionId} elapsedMs=${elapsed}`);
+                void session.abort();
+            }
+        }, 2000);
+        try {
+            await session.prompt(params.prompt);
+            if (timedOut) {
+                throw new Error(`Model request timed out after ${config.modelTimeoutMs}ms`);
+            }
+        }
+        catch (error) {
+            if (userAbortRequested) {
+                throw new Error("Cancelled by user.");
+            }
+            if (timedOut) {
+                const suffix = timedOutStreaming ? " (streaming)" : "";
+                const ms = timedOutAfterMs || config.modelTimeoutMs;
+                throw new Error(`Model request timed out after ${ms}ms${suffix}`);
+            }
+            throw error;
+        }
+        if (heartbeat)
+            clearInterval(heartbeat);
+        const lastAssistant = findLastAssistantMessage(session.messages);
+        if (lastAssistant) {
+            const stopReason = lastAssistant
+                ?.stopReason;
+            const errorMessage = lastAssistant
+                ?.errorMessage;
+            if (stopReason === "error") {
+                console.warn(`[tg-agent] model error session=${params.sessionId} error=${errorMessage ?? "unknown"}`);
+                throw new Error(errorMessage ?? "Model error without details.");
+            }
+        }
+        const text = extractAssistantText(session.messages, session);
+        if (!text) {
+            const summary = summarizeMessages(session.messages);
+            console.warn(`[tg-agent] empty response session=${params.sessionId} ${summary}`);
+            throw new Error("No assistant response.");
+        }
+        return {
+            text,
+            sessionFile,
+            sessionId: session.sessionId,
+            modelProvider: session.model?.provider ?? provider,
+            modelId: session.model?.id ?? modelId,
+            modelFallbackMessage,
+        };
+    }
+    finally {
+        if (heartbeat)
+            clearInterval(heartbeat);
+        if (timeoutInterval)
+            clearInterval(timeoutInterval);
+        unsubscribe();
+        const manager = sessionManager;
+        manager.flushPendingToolResults?.();
+        session.dispose();
+    }
+}

package/dist/piAiRunner.js

@@ -0,0 +1,99 @@
+import { completeSimple, getModel, } from "@mariozechner/pi-ai";
+import { config } from "./config.js";
+import { resolveApiKeyForProvider } from "./auth.js";
+const CODEX_MODEL_ALIASES = {
+    "codex-mini-latest": "gpt-5.1-codex-mini",
+    "codex-max-latest": "gpt-5.1-codex-max",
+    "codex-latest": "gpt-5.2-codex",
+};
+function splitModelRef(ref, fallbackProvider) {
+    const trimmed = ref.trim();
+    if (!trimmed) {
+        return { provider: fallbackProvider, modelId: "" };
+    }
+    if (trimmed.includes("/")) {
+        const [provider, modelId] = trimmed.split("/", 2);
+        return { provider: provider.trim() || fallbackProvider, modelId: modelId.trim() };
+    }
+    return { provider: fallbackProvider, modelId: trimmed };
+}
+function normalizeModelId(provider, modelId) {
+    if (provider !== "openai-codex") {
+        return modelId;
+    }
+    const mapped = CODEX_MODEL_ALIASES[modelId];
+    return mapped ?? modelId;
+}
+function toAssistantMessage(text, model, timestamp) {
+    return {
+        role: "assistant",
+        content: [{ type: "text", text }],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                total: 0,
+            },
+        },
+        stopReason: "stop",
+        timestamp,
+    };
+}
+function buildContextMessages(localMessages, model) {
+    return localMessages.map((message) => {
+        if (message.role === "user") {
+            return {
+                role: "user",
+                content: message.content,
+                timestamp: message.ts,
+            };
+        }
+        return toAssistantMessage(message.content, model, message.ts);
+    });
+}
+function extractText(assistant) {
+    const textBlocks = assistant.content.filter((block) => block.type === "text");
+    const text = textBlocks.map((block) => block.text.trim()).filter(Boolean).join("\n\n");
+    if (text) {
+        return text;
+    }
+    const thinkingBlocks = assistant.content.filter((block) => block.type === "thinking");
+    const thinking = thinkingBlocks
+        .map((block) => (block.type === "thinking" ? block.thinking.trim() : ""))
+        .filter(Boolean)
+        .join("\n\n");
+    return thinking || "Empty response.";
+}
+export async function runPiCompletion(localMessages, systemPrompt, sessionId) {
+    const providerRaw = config.modelProvider || "openai-codex";
+    const modelRef = config.modelRef || "gpt-5.2";
+    const { provider, modelId: rawModelId } = splitModelRef(modelRef, providerRaw);
+    const modelId = normalizeModelId(provider, rawModelId || "gpt-5.2");
+    const model = getModel(provider, modelId);
+    const { apiKey } = resolveApiKeyForProvider(provider);
+    const context = {
+        systemPrompt,
+        messages: buildContextMessages(localMessages, model),
+    };
+    const assistant = await completeSimple(model, context, {
+        apiKey,
+        sessionId,
+        maxTokens: config.maxOutputTokens || undefined,
+    });
+    return {
+        text: extractText(assistant),
+        assistant,
+        provider,
+        modelId: model.id,
+    };
+}

package/dist/proxy.js

@@ -0,0 +1,19 @@
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+import { resolveFetchProxyInfo } from "./auth.js";
+let applied = false;
+let appliedInfo = null;
+export function applyFetchProxy() {
+    if (applied) {
+        return appliedInfo;
+    }
+    applied = true;
+    const proxy = resolveFetchProxyInfo();
+    if (!proxy) {
+        appliedInfo = null;
+        return null;
+    }
+    const dispatcher = new ProxyAgent(proxy.url);
+    setGlobalDispatcher(dispatcher);
+    appliedInfo = proxy;
+    return proxy;
+}

package/dist/sessionStore.js

@@ -0,0 +1,138 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { config } from "./config.js";
+import { atomicWriteJson, ensureDir, nowMs, shortId } from "./utils.js";
+const cache = new Map();
+function userFilePath(userId) {
+    return path.join(config.sessionDir, `${userId}.json`);
+}
+function sanitizeSegment(value) {
+    return value.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+export function sessionFilePath(userId, sessionId) {
+    const safeUser = sanitizeSegment(userId);
+    const safeSession = sanitizeSegment(sessionId);
+    return path.join(config.sessionDir, `${safeUser}-${safeSession}.jsonl`);
+}
+export async function deleteSessionFile(userId, sessionId) {
+    const filePath = sessionFilePath(userId, sessionId);
+    try {
+        await fs.unlink(filePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+}
+function normalizeState(userId, raw) {
+    const sessions = raw?.sessions ?? {};
+    const activeSessionId = raw?.activeSessionId ?? null;
+    const normalized = {
+        userId,
+        activeSessionId,
+        sessions,
+    };
+    if (!activeSessionId || !sessions[activeSessionId]) {
+        normalized.activeSessionId = null;
+    }
+    return normalized;
+}
+export async function loadUserState(userId) {
+    await ensureDir(config.sessionDir);
+    const cached = cache.get(userId);
+    if (cached) {
+        return cached;
+    }
+    const filePath = userFilePath(userId);
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        const normalized = normalizeState(userId, parsed);
+        cache.set(userId, normalized);
+        return normalized;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            const state = normalizeState(userId, {});
+            cache.set(userId, state);
+            return state;
+        }
+        throw error;
+    }
+}
+export async function saveUserState(state) {
+    await ensureDir(config.sessionDir);
+    const filePath = userFilePath(state.userId);
+    await atomicWriteJson(filePath, state);
+    cache.set(state.userId, state);
+}
+export function listSessions(state) {
+    return Object.values(state.sessions).sort((a, b) => b.updatedAt - a.updatedAt);
+}
+export function pruneExpiredSessions(state, now = nowMs()) {
+    const removed = [];
+    for (const [id, session] of Object.entries(state.sessions)) {
+        if (now - session.updatedAt > config.sessionTtlMs) {
+            delete state.sessions[id];
+            removed.push(id);
+        }
+    }
+    if (state.activeSessionId && !state.sessions[state.activeSessionId]) {
+        state.activeSessionId = null;
+    }
+    return removed;
+}
+export function createSession(state, title) {
+    const count = Object.keys(state.sessions).length;
+    if (count >= config.maxSessions) {
+        throw new Error("Max sessions reached");
+    }
+    const id = shortId();
+    const now = nowMs();
+    const session = {
+        id,
+        title: title && title.length > 0 ? title : `session-${id}`,
+        messages: [],
+        createdAt: now,
+        updatedAt: now,
+    };
+    state.sessions[id] = session;
+    state.activeSessionId = id;
+    return session;
+}
+export function setActiveSession(state, sessionId) {
+    if (!state.sessions[sessionId]) {
+        return false;
+    }
+    state.activeSessionId = sessionId;
+    return true;
+}
+export function getActiveSession(state) {
+    if (!state.activeSessionId) {
+        return null;
+    }
+    return state.sessions[state.activeSessionId] ?? null;
+}
+export function closeSession(state, sessionId) {
+    if (!state.sessions[sessionId]) {
+        return false;
+    }
+    delete state.sessions[sessionId];
+    if (state.activeSessionId === sessionId) {
+        state.activeSessionId = null;
+    }
+    return true;
+}
+export function resetSession(session) {
+    session.messages = [];
+    session.updatedAt = nowMs();
+}
+export function appendMessage(session, message, maxHistoryMessages) {
+    session.messages.push(message);
+    if (session.messages.length > maxHistoryMessages) {
+        session.messages = session.messages.slice(-maxHistoryMessages);
+    }
+    session.updatedAt = nowMs();
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};