agent-sin 0.1.11 → 0.1.15

package/dist/runtimes/codex-app-server.d.ts

@@ -30,6 +30,10 @@ export interface CodexAppServerOptions {
     turnTimeoutMs?: number;
     onStderr?: (chunk: string) => void;
 }
+export interface CodexTurnResult {
+    text: string;
+    generatedImagePaths: string[];
+}
 export declare function getSharedCodexAppServer(model?: string): CodexAppServerSession;
 export declare function shutdownSharedCodexAppServer(): Promise<void>;
 export declare class CodexAppServerSession {
@@ -42,7 +46,7 @@ export declare class CodexAppServerSession {
     private readonly options;
     private exitReason;
     constructor(options?: CodexAppServerOptions);
-    sendTurn(text: string, options?: CodexTurnOptions): Promise<string>;
+    sendTurn(text: string, options?: CodexTurnOptions): Promise<CodexTurnResult>;
     stop(): Promise<void>;
     isRunning(): boolean;
     private ensureStarted;

package/dist/runtimes/codex-app-server.js

@@ -1,7 +1,13 @@
 import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { detectImageMimeTypeFromBuffer, imageExtensionForMimeType, } from "../core/image-attachments.js";
 import { l } from "../core/i18n.js";
 const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
 const DEFAULT_TURN_TIMEOUT_MS = 5 * 60_000;
+const MAX_GENERATED_IMAGE_BYTES = 20 * 1024 * 1024;
 function snippet(value) {
     if (typeof value !== "string") {
         return undefined;
@@ -40,8 +46,8 @@ export class CodexAppServerSession {
     constructor(options = {}) {
         const baseArgs = options.args ? [...options.args] : ["app-server"];
         const model = options.model || process.env.AGENT_SIN_CODEX_MODEL;
-        if (model && !baseArgs.includes("--model") && !baseArgs.includes("-m")) {
-            baseArgs.push("--model", model);
+        if (model && !hasConfigOverride(baseArgs, "model")) {
+            baseArgs.push("-c", `model=${JSON.stringify(model)}`);
         }
         this.options = {
             bin: options.bin || process.env.AGENT_SIN_CODEX_BIN || "codex",
@@ -211,6 +217,9 @@ export class CodexAppServerSession {
         return new Promise((resolve, reject) => {
             let assistantText = "";
             let settled = false;
+            const generatedImagePaths = [];
+            const generatedImageKeys = new Set();
+            const generatedImageTasks = [];
             const emit = (event) => {
                 if (!options.onProgress) {
                     return;
@@ -259,6 +268,17 @@ export class CodexAppServerSession {
                     else if (item && (item.type === "command" || item.type === "tool_call")) {
                         emit({ kind: "tool", name: item.name || item.type, text: l("done", "完了") });
                     }
+                    else if (item && item.type === "imageGeneration") {
+                        generatedImageTasks.push(captureGeneratedImage(item, options.cwd, generatedImagePaths, generatedImageKeys));
+                        emit({ kind: "tool", name: "image_generation", text: l("done", "完了") });
+                    }
+                }
+                else if (method === "rawResponseItem/completed") {
+                    const item = params.item;
+                    if (item && item.type === "image_generation_call") {
+                        generatedImageTasks.push(captureGeneratedImage(item, options.cwd, generatedImagePaths, generatedImageKeys));
+                        emit({ kind: "tool", name: "image_generation", text: l("done", "完了") });
+                    }
                 }
                 else if (method === "turn/completed") {
                     const turn = params.turn;
@@ -270,6 +290,11 @@ export class CodexAppServerSession {
                         if (fromTurn) {
                             assistantText = fromTurn;
                         }
+                        for (const entry of turn.items) {
+                            if (entry && entry.type === "imageGeneration") {
+                                generatedImageTasks.push(captureGeneratedImage(entry, options.cwd, generatedImagePaths, generatedImageKeys));
+                            }
+                        }
                     }
                     finish(true, undefined);
                 }
@@ -285,12 +310,23 @@ export class CodexAppServerSession {
                 settled = true;
                 clearTimeout(timeout);
                 this.notificationHandlers.delete(handler);
-                if (ok) {
-                    resolve(assistantText);
-                }
-                else {
-                    reject(error || new Error("codex app-server: unknown failure"));
-                }
+                Promise.all(generatedImageTasks)
+                    .then(() => {
+                    if (ok) {
+                        resolve({ text: assistantText, generatedImagePaths });
+                    }
+                    else {
+                        reject(error || new Error("codex app-server: unknown failure"));
+                    }
+                })
+                    .catch((imageError) => {
+                    if (ok) {
+                        resolve({ text: assistantText, generatedImagePaths });
+                    }
+                    else {
+                        reject(error || imageError);
+                    }
+                });
             };
             const timeout = setTimeout(() => {
                 finish(false, new Error(`codex app-server: turn timed out after ${this.options.turnTimeoutMs}ms`));
@@ -306,3 +342,106 @@ export class CodexAppServerSession {
         });
     }
 }
+function hasConfigOverride(args, key) {
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if ((arg === "-c" || arg === "--config") && args[index + 1]?.startsWith(`${key}=`)) {
+            return true;
+        }
+        if (arg.startsWith("-c") && arg.slice(2).trimStart().startsWith(`${key}=`)) {
+            return true;
+        }
+        if (arg.startsWith("--config=") && arg.slice("--config=".length).startsWith(`${key}=`)) {
+            return true;
+        }
+    }
+    return false;
+}
+async function captureGeneratedImage(item, cwd, paths, keys) {
+    if (!item || typeof item !== "object")
+        return;
+    const record = item;
+    const id = typeof record.id === "string" ? record.id : undefined;
+    const savedPath = typeof record.savedPath === "string" ? record.savedPath : undefined;
+    const result = typeof record.result === "string" ? record.result : undefined;
+    const key = id || (result ? imageResultKey(result) : savedPath);
+    if (key && keys.has(key))
+        return;
+    if (key)
+        keys.add(key);
+    if (savedPath) {
+        const usable = await existingImagePath(savedPath);
+        if (usable && !paths.includes(usable)) {
+            paths.push(usable);
+            return;
+        }
+    }
+    if (!result)
+        return;
+    const resultPath = await persistImageGenerationResult(result, cwd, id);
+    if (resultPath && !paths.includes(resultPath)) {
+        paths.push(resultPath);
+    }
+}
+async function existingImagePath(filePath) {
+    try {
+        const info = await stat(filePath);
+        return info.isFile() && info.size > 0 ? filePath : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function persistImageGenerationResult(value, cwd, id) {
+    const parsed = parseImageGenerationResult(value);
+    if (!parsed || parsed.buffer.length === 0 || parsed.buffer.length > MAX_GENERATED_IMAGE_BYTES) {
+        return null;
+    }
+    const mimeType = parsed.mimeType || detectImageMimeTypeFromBuffer(parsed.buffer);
+    const ext = imageExtensionForMimeType(mimeType);
+    const safeId = (id || "image").replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 40) || "image";
+    const hash = crypto.createHash("sha256").update(parsed.buffer).digest("hex").slice(0, 10);
+    const filename = `${new Date().toISOString().replace(/[:.]/g, "-")}-${safeId}-${hash}${ext}`;
+    for (const dir of candidateImageDirs(cwd)) {
+        try {
+            await mkdir(dir, { recursive: true });
+            const filePath = path.join(dir, filename);
+            await writeFile(filePath, parsed.buffer);
+            return filePath;
+        }
+        catch {
+            // Try the fallback directory.
+        }
+    }
+    return null;
+}
+function parseImageGenerationResult(value) {
+    const trimmed = value.trim();
+    const dataUrl = trimmed.match(/^data:(image\/[a-z0-9.+-]+);base64,([\s\S]+)$/i);
+    const mimeType = dataUrl?.[1];
+    const rawBase64 = dataUrl ? dataUrl[2] : trimmed;
+    if (rawBase64.length === 0 || rawBase64.length > Math.ceil(MAX_GENERATED_IMAGE_BYTES * 1.4)) {
+        return null;
+    }
+    if (!/^[A-Za-z0-9+/=\s_-]+$/.test(rawBase64)) {
+        return null;
+    }
+    const normalized = rawBase64.replace(/[\s_-]/g, (char) => (char === "-" ? "+" : char === "_" ? "/" : ""));
+    try {
+        return { buffer: Buffer.from(normalized, "base64"), mimeType };
+    }
+    catch {
+        return null;
+    }
+}
+function candidateImageDirs(cwd) {
+    const dirs = [];
+    if (cwd) {
+        dirs.push(path.join(cwd, "codex-images"));
+    }
+    dirs.push(path.join(os.tmpdir(), "agent-sin-codex-images"));
+    return dirs;
+}
+function imageResultKey(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}

package/dist/runtimes/python-runner.js

@@ -4,10 +4,13 @@ import path from "node:path";
 import { resolveSkillEntryPath } from "../core/skill-registry.js";
 import { getAiProvider } from "../core/ai-provider.js";
 import { notify as runNotify } from "../core/notifier.js";
+import { appendSkillHistory, listSkillHistory, readSkillHistoryRaw, } from "../core/skill-history.js";
 const AI_REQUEST_PREFIX = "AGENT_SIN_AI_REQUEST::";
 const AI_RESPONSE_PREFIX = "AGENT_SIN_AI_RESPONSE::";
 const NOTIFY_REQUEST_PREFIX = "AGENT_SIN_NOTIFY_REQUEST::";
 const NOTIFY_RESPONSE_PREFIX = "AGENT_SIN_NOTIFY_RESPONSE::";
+const HISTORY_REQUEST_PREFIX = "AGENT_SIN_HISTORY_REQUEST::";
+const HISTORY_RESPONSE_PREFIX = "AGENT_SIN_HISTORY_RESPONSE::";
 const CTX_LOG_PATTERN = /^\[(info|warn|error)\]\s+([\s\S]*)$/;
 export function candidatePythonInterpreters(config, platform = process.platform) {
     const venvDir = path.join(config.workspace, ".venv");
@@ -83,6 +86,13 @@ export async function runPythonSkill(config, manifest, input) {
             });
             return;
         }
+        if (line.startsWith(HISTORY_REQUEST_PREFIX)) {
+            const payloadJson = line.slice(HISTORY_REQUEST_PREFIX.length);
+            handleHistoryRequest(payloadJson).catch((error) => {
+                stderrLines.push(`[history-error] ${error instanceof Error ? error.message : String(error)}`);
+            });
+            return;
+        }
         const ctxMatch = line.match(CTX_LOG_PATTERN);
         if (ctxMatch) {
             ctxLogs.push({ level: ctxMatch[1], message: ctxMatch[2] });
@@ -103,6 +113,7 @@ export async function runPythonSkill(config, manifest, input) {
             const response = await getAiProvider()(config, {
                 model_id: request.model_id,
                 messages: request.messages,
+                cwd: config.workspace,
             });
             child.stdin.write(`${AI_RESPONSE_PREFIX}${JSON.stringify({ id: request.id, ok: true, response })}\n`);
         }
@@ -114,6 +125,40 @@ export async function runPythonSkill(config, manifest, input) {
             })}\n`);
         }
     }
+    async function handleHistoryRequest(payloadJson) {
+        let request;
+        try {
+            request = JSON.parse(payloadJson);
+        }
+        catch (error) {
+            child.stdin.write(`${HISTORY_RESPONSE_PREFIX}${JSON.stringify({ id: "?", ok: false, error: `Invalid history request JSON: ${String(error)}` })}\n`);
+            return;
+        }
+        try {
+            const payload = request.payload || {};
+            let data = null;
+            if (request.op === "append") {
+                data = await appendSkillHistory(config, manifest, payload);
+            }
+            else if (request.op === "list") {
+                data = await listSkillHistory(config, manifest, payload);
+            }
+            else if (request.op === "read") {
+                data = await readSkillHistoryRaw(config, manifest, payload);
+            }
+            else {
+                throw new Error(`Unknown history op: ${request.op}`);
+            }
+            child.stdin.write(`${HISTORY_RESPONSE_PREFIX}${JSON.stringify({ id: request.id, ok: true, data })}\n`);
+        }
+        catch (error) {
+            child.stdin.write(`${HISTORY_RESPONSE_PREFIX}${JSON.stringify({
+                id: request.id,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            })}\n`);
+        }
+    }
     async function handleNotifyRequest(payloadJson) {
         let request;
         try {
@@ -134,6 +179,15 @@ export async function runPythonSkill(config, manifest, input) {
                 to: typeof args.to === "string" ? args.to : undefined,
                 discordThreadId: typeof args.discordThreadId === "string" ? args.discordThreadId : undefined,
                 telegramThreadId: typeof args.telegramThreadId === "string" ? args.telegramThreadId : undefined,
+                filePath: typeof args.filePath === "string" ? args.filePath : undefined,
+                filePaths: Array.isArray(args.filePaths)
+                    ? args.filePaths.filter((item) => typeof item === "string")
+                    : undefined,
+                imagePath: typeof args.imagePath === "string" ? args.imagePath : undefined,
+                imagePaths: Array.isArray(args.imagePaths)
+                    ? args.imagePaths.filter((item) => typeof item === "string")
+                    : undefined,
+                cwd: config.workspace,
             });
             child.stdin.write(`${NOTIFY_RESPONSE_PREFIX}${JSON.stringify({ id: request.id, ok: result.ok, channel: result.channel, detail: result.detail })}\n`);
         }
@@ -238,6 +292,7 @@ class AI:
             "model_id": response.get("model_id"),
             "provider": response.get("provider"),
             "text": response.get("text", ""),
+            "generated_images": response.get("generated_images") or [],
         }
 
 class Memory:
@@ -275,11 +330,38 @@ async def notify_call(args):
         "detail": envelope.get("detail"),
     }
 
+async def history_call(op, payload):
+    request_id = str(uuid.uuid4())
+    request = {"id": request_id, "op": op, "payload": payload or {}}
+    print("AGENT_SIN_HISTORY_REQUEST::" + json.dumps(request, ensure_ascii=False, default=str), file=sys.stderr, flush=True)
+    line = sys.stdin.readline()
+    if not line:
+        raise RuntimeError("History channel closed")
+    marker = "AGENT_SIN_HISTORY_RESPONSE::"
+    idx = line.find(marker)
+    if idx < 0:
+        raise RuntimeError(f"Unexpected history response: {line.strip()}")
+    envelope = json.loads(line[idx + len(marker):])
+    if not envelope.get("ok"):
+        raise RuntimeError(envelope.get("error") or "History error")
+    return envelope.get("data")
+
+class History:
+    async def append(self, args):
+        if not isinstance(args, dict):
+            raise RuntimeError("ctx.history.append requires a dict argument")
+        return await history_call("append", args)
+    async def list(self, options=None):
+        return await history_call("list", options or {})
+    async def read(self, options=None):
+        return await history_call("read", options or {})
+
 class Ctx:
     def __init__(self):
         self.log = Log()
         self.ai = AI()
         self.memory = Memory()
+        self.history = History()
     def now(self):
         return datetime.now(timezone.utc).isoformat()
     async def notify(self, args):

package/dist/runtimes/typescript-runner.js

@@ -7,6 +7,7 @@ import ts from "typescript";
 import { resolveSkillEntryPath } from "../core/skill-registry.js";
 import { getAiProvider } from "../core/ai-provider.js";
 import { notify as runNotify } from "../core/notifier.js";
+import { appendSkillHistory, listSkillHistory, readSkillHistoryRaw, } from "../core/skill-history.js";
 export async function runTypeScriptSkill(config, manifest, input) {
     const entry = await resolveSkillEntryPath(manifest);
     const skillDir = await realpath(manifest.dir);
@@ -113,13 +114,14 @@ function createContext(config, manifest, initialMemory) {
                             { role: "system", content: `You are an AI step "${step.id}" of an Agent-Sin skill. Purpose: ${step.purpose}` },
                             { role: "user", content: typeof payload === "string" ? payload : JSON.stringify(payload) },
                         ];
-                        const response = await getAiProvider()(config, { model_id: modelId, messages });
+                        const response = await getAiProvider()(config, { model_id: modelId, messages, cwd: config.workspace });
                         return {
                             status: "ok",
                             step_id: stepId,
                             model_id: modelId,
                             provider: response.provider,
                             text: response.text,
+                            generated_images: response.generated_images || [],
                         };
                     }
                     catch (error) {
@@ -145,6 +147,11 @@ function createContext(config, manifest, initialMemory) {
                     to: args.to,
                     discordThreadId: args.discordThreadId,
                     telegramThreadId: args.telegramThreadId,
+                    filePath: args.filePath,
+                    filePaths: args.filePaths,
+                    imagePath: args.imagePath,
+                    imagePaths: args.imagePaths,
+                    cwd: config.workspace,
                 });
                 return { ok: result.ok, channel: result.channel, detail: result.detail };
             },
@@ -164,6 +171,11 @@ function createContext(config, manifest, initialMemory) {
                     return true;
                 },
             },
+            history: {
+                append: async (args) => appendSkillHistory(config, manifest, args),
+                list: async (options = {}) => listSkillHistory(config, manifest, options),
+                read: async (options = {}) => readSkillHistoryRaw(config, manifest, options),
+            },
             now: () => new Date().toISOString(),
         },
         memoryUpdates,

package/dist/skills-sdk/types.d.ts

@@ -1,3 +1,14 @@
+export interface SkillInputSources {
+    workspace?: string;
+    notes_dir?: string;
+    memory_dir?: string;
+    index_dir?: string;
+    logs_dir?: string;
+    skill_output_dir?: string;
+    skillOutputDir?: string;
+    locale?: string;
+    [key: string]: unknown;
+}
 export interface SkillInput {
     args: Record<string, unknown>;
     trigger: {
@@ -5,19 +16,23 @@ export interface SkillInput {
         id: string;
         time: string;
     };
-    sources: Record<string, unknown>;
+    sources: SkillInputSources;
     memory: Record<string, unknown>;
 }
-export type NotifyChannel = "auto" | "macos" | "discord" | "telegram" | "slack" | "mail" | "stderr";
+export type NotifyChannel = "auto" | "macos" | "discord" | "telegram" | "slack" | "mail" | "g2" | "stderr";
 export interface NotifyArgs {
-    title: string;
-    body: string;
+    title?: string;
+    body?: string;
     subtitle?: string;
     sound?: boolean;
     channel?: NotifyChannel;
     to?: string;
     discordThreadId?: string;
     telegramThreadId?: string;
+    filePath?: string;
+    filePaths?: string[];
+    imagePath?: string;
+    imagePaths?: string[];
 }
 export interface NotifyOutcome {
     ok: boolean;

package/dist/telegram/bot.d.ts

@@ -90,5 +90,6 @@ export declare function shouldUseTelegramDraftStream(message: TelegramMessage):
 export declare function telegramSendPayload(chatId: string, content: string, options?: TelegramSendOptions): Record<string, unknown>;
 export declare function telegramDraftPayload(message: TelegramMessage, draftId: number, text: string): Record<string, unknown>;
 export declare function formatTelegramDraftProgress(event: AiProgressEvent): string | null;
+export declare function formatTelegramChatDraftProgress(event: AiProgressEvent): string | null;
 export declare function loadTelegramHistories(filePath: string): Promise<Map<string, ChatTurn[]>>;
 export declare function loadTelegramIntentRuntimes(filePath: string): Promise<Map<string, IntentRuntime>>;