agent-sin 0.1.12 → 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>>;

package/dist/telegram/bot.js

@@ -7,6 +7,7 @@ import { createIntentRuntime, renderBuildFooter, shouldShowBuildFooter, } from "
 import { routeConversationMessage, } from "../builder/conversation-router.js";
 import { cleanProgressText, formatBuildProgress, progressIntervalMs } from "../builder/progress-format.js";
 import { chunkText, cleanAttachmentText, formatAttachmentLabel, formatBytes, guessImageMimeType, indentAttachmentContent, isImageLikeFile, isTextLikeFile, } from "../core/message-utils.js";
+import { collectLocalFileAttachments, collectLocalImageAttachments, } from "../core/image-attachments.js";
 import { isEmptyIntentRuntime, loadIntentRuntimeMap, saveIntentRuntimeMap, } from "../builder/intent-runtime-store.js";
 import { inferLocaleFromText, l, lLines, withLocale } from "../core/i18n.js";
 import { consumeUpdateBanner, scheduleUpdateCheck } from "../core/update-notifier.js";
@@ -351,20 +352,20 @@ async function handleTelegramMessage(state, message) {
         draft.update(l("Thinking", "考えています"), { force: true });
         const prevMode = intentRuntime.mode;
         try {
-            const lines = await routeTelegramMessage(state, userText, history, intentRuntime, chatKey, chatId, threadId, message.message_id, draft, userMessage.images);
+            const routed = await routeTelegramMessage(state, userText, history, intentRuntime, chatKey, chatId, threadId, message.message_id, draft, userMessage.images);
             typing.stop();
             trimHistory(history);
             void saveTelegramHistories(state);
             void saveTelegramIntentRuntimes(state);
             const isBuildEntry = prevMode !== "build" && intentRuntime.mode === "build";
-            const decorated = withTelegramModeBadge(intentRuntime, lines, { userText, isBuildEntry });
+            const decorated = withTelegramModeBadge(intentRuntime, routed.lines, { userText, isBuildEntry });
             scheduleUpdateCheck(state.config.workspace);
             const banner = await consumeUpdateBanner(state.config.workspace);
             const finalLines = banner ? [banner, "", ...decorated] : decorated;
             const reply = finalLines.filter((line) => line !== undefined && line !== null).join("\n").trim();
             draft.update(l("Sending reply", "応答を送信しています"), { force: true });
             await draft.finish();
-            await sendTelegramMessage(state, chatId, reply || l("(no response)", "（応答なし）"), sendOptions);
+            await sendTelegramMessageWithLocalAttachments(state, chatId, reply || l("(no response)", "（応答なし）"), sendOptions, routed.localAttachmentPaths);
         }
         catch (error) {
             typing.stop();
@@ -398,7 +399,8 @@ async function refreshTelegramStateConfig(state) {
     }
 }
 async function routeTelegramMessage(state, text, history, intentRuntime, chatKey, chatId, threadId, replyToMessageId, draft, images = []) {
-    return routeConversationMessage({
+    const localAttachmentPaths = [];
+    const lines = await routeConversationMessage({
         config: state.config,
         text,
         history,
@@ -408,7 +410,11 @@ async function routeTelegramMessage(state, text, history, intentRuntime, chatKey
         createBuildProgress: () => createTelegramBuildProgressReporter(state, chatKey, chatId, threadId, replyToMessageId, draft),
         onChatProgress: (event) => draft.onChatProgress(event),
         onAiProgress: (event) => draft.onAiProgress(event),
+        onLocalAttachments: (paths) => {
+            localAttachmentPaths.push(...paths);
+        },
     });
+    return { lines, localAttachmentPaths };
 }
 function createTelegramBuildProgressReporter(state, chatKey, chatId, threadId, replyToMessageId, draft) {
     const minIntervalMs = telegramProgressIntervalMs();
@@ -712,7 +718,7 @@ async function persistTelegramAttachmentBuffer(state, attachment, buffer, mimeTy
         const HH = String(now.getHours()).padStart(2, "0");
         const mm = String(now.getMinutes()).padStart(2, "0");
         const ss = String(now.getSeconds()).padStart(2, "0");
-        const dir = path.join(state.config.notes_dir, "attachments", yyyy, MM);
+        const dir = path.join(state.config.memory_dir, "attachments", yyyy, MM);
         await mkdir(dir, { recursive: true });
         const ext = pickAttachmentExtension(attachment.filename, mimeType);
         const random = Math.random().toString(36).slice(2, 8);
@@ -903,6 +909,12 @@ export function formatTelegramDraftProgress(event) {
             return null;
     }
 }
+export function formatTelegramChatDraftProgress(event) {
+    if (event.kind === "message") {
+        return l("Preparing reply", "応答を整理しています");
+    }
+    return formatTelegramDraftProgress(event);
+}
 function createTelegramDraftStreamer(state, message) {
     if (!shouldUseTelegramDraftStream(message)) {
         return noopTelegramDraftStreamer();
@@ -969,9 +981,9 @@ function createTelegramDraftStreamer(state, message) {
             }
         },
         onAiProgress(event) {
-            const text = formatTelegramDraftProgress(event);
+            const text = formatTelegramChatDraftProgress(event);
             if (text)
-                enqueue(text, event.kind === "message");
+                enqueue(text);
         },
         onBuildProgress(event) {
             const text = formatTelegramDraftProgress(event);
@@ -1071,6 +1083,60 @@ async function sendTelegramMessage(state, chatId, content, options = {}) {
         }
     }
 }
+async function sendTelegramMessageWithLocalAttachments(state, chatId, content, options = {}, localAttachmentPaths = []) {
+    const sanitized = stripInternalControlBlocks(content);
+    const explicitAttachments = await collectLocalFileAttachments({
+        paths: localAttachmentPaths,
+        cwd: state.config.workspace,
+        allowedRoots: [state.config.workspace, state.config.notes_dir],
+    });
+    const inlineImages = await collectLocalImageAttachments({
+        text: sanitized,
+        cwd: state.config.workspace,
+        allowedRoots: [state.config.workspace, state.config.notes_dir],
+    });
+    const attachments = dedupeLocalAttachments([...explicitAttachments, ...inlineImages]);
+    if (sanitized.trim()) {
+        await sendTelegramMessage(state, chatId, sanitized, options);
+    }
+    for (let index = 0; index < attachments.length; index += 1) {
+        await sendTelegramFileAttachment(state, chatId, attachments[index], index === 0 && !sanitized.trim() ? options : { threadId: options.threadId });
+    }
+}
+async function sendTelegramFileAttachment(state, chatId, attachment, options = {}) {
+    const method = shouldSendTelegramAsPhoto(attachment) ? "sendPhoto" : "sendDocument";
+    const fileField = method === "sendPhoto" ? "photo" : "document";
+    const payload = telegramFilePayload(chatId, options);
+    try {
+        const buffer = await readFile(attachment.path);
+        await telegramMultipartApi(state, method, payload, fileField, attachment.filename, attachment.mimeType, buffer);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`agent-sin telegram: file send error: ${message}`);
+        await appendEventLog(state.config, {
+            level: "error",
+            source: "telegram",
+            event: "file_send_error",
+            message,
+            details: { chat_id: chatId, path: attachment.path },
+        });
+    }
+}
+function shouldSendTelegramAsPhoto(attachment) {
+    return attachment.isImage && ["image/png", "image/jpeg", "image/webp"].includes(attachment.mimeType.toLowerCase());
+}
+function dedupeLocalAttachments(attachments) {
+    const seen = new Set();
+    const out = [];
+    for (const attachment of attachments) {
+        if (seen.has(attachment.path))
+            continue;
+        seen.add(attachment.path);
+        out.push(attachment);
+    }
+    return out;
+}
 async function sendTelegramChatAction(state, chatId, threadId) {
     try {
         const payload = {
@@ -1086,6 +1152,21 @@ async function sendTelegramChatAction(state, chatId, threadId) {
         // typing indicator is a hint; ignore failures
     }
 }
+function telegramFilePayload(chatId, options = {}) {
+    const payload = {
+        chat_id: chatId,
+    };
+    if (options.threadId) {
+        payload.message_thread_id = options.threadId;
+    }
+    if (options.replyToMessageId && process.env.AGENT_SIN_TELEGRAM_REPLY_TO_MESSAGE !== "0") {
+        payload.reply_parameters = {
+            message_id: options.replyToMessageId,
+            allow_sending_without_reply: true,
+        };
+    }
+    return payload;
+}
 async function telegramApi(state, method, payload) {
     const response = await fetch(`${TELEGRAM_API_BASE}/bot${state.token}/${method}`, {
         method: "POST",
@@ -1102,6 +1183,33 @@ async function telegramApi(state, method, payload) {
     }
     return data.result;
 }
+async function telegramMultipartApi(state, method, payload, fileField, filename, mimeType, buffer) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(payload)) {
+        if (value === undefined || value === null)
+            continue;
+        form.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+    }
+    form.append(fileField, blobFromBuffer(buffer, mimeType), filename);
+    const response = await fetch(`${TELEGRAM_API_BASE}/bot${state.token}/${method}`, {
+        method: "POST",
+        body: form,
+    });
+    if (!response.ok) {
+        const detail = await response.text().catch(() => "");
+        throw new Error(`HTTP ${response.status} ${detail.slice(0, 200)}`);
+    }
+    const data = (await response.json());
+    if (!data.ok) {
+        throw new Error(data.description || "Telegram API error");
+    }
+    return data.result;
+}
+function blobFromBuffer(buffer, type) {
+    const bytes = new Uint8Array(buffer.length);
+    bytes.set(buffer);
+    return new Blob([bytes.buffer], { type });
+}
 async function loadTelegramOffset(filePath) {
     try {
         const raw = await readFile(filePath, "utf8");