agent-sin 0.1.0

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

@@ -0,0 +1,53 @@
+export type CodexProgressEvent = {
+    kind: "thinking";
+    text?: string;
+} | {
+    kind: "tool";
+    name?: string;
+    text?: string;
+} | {
+    kind: "message";
+    text?: string;
+} | {
+    kind: "info";
+    text: string;
+};
+export type CodexProgressHandler = (event: CodexProgressEvent) => void;
+export type CodexSandboxMode = "read-only" | "workspace-write" | "danger-full-access";
+export type CodexApprovalPolicy = "untrusted" | "on-failure" | "on-request" | "never";
+export interface CodexTurnOptions {
+    cwd?: string;
+    effort?: "low" | "medium" | "high" | "xhigh";
+    sandbox?: CodexSandboxMode;
+    approvalPolicy?: CodexApprovalPolicy;
+    onProgress?: CodexProgressHandler;
+}
+export interface CodexAppServerOptions {
+    bin?: string;
+    args?: string[];
+    model?: string;
+    startupTimeoutMs?: number;
+    turnTimeoutMs?: number;
+    onStderr?: (chunk: string) => void;
+}
+export declare function getSharedCodexAppServer(model?: string): CodexAppServerSession;
+export declare function shutdownSharedCodexAppServer(): Promise<void>;
+export declare class CodexAppServerSession {
+    private child;
+    private buffer;
+    private nextId;
+    private readonly pending;
+    private readonly notificationHandlers;
+    private starting;
+    private readonly options;
+    private exitReason;
+    constructor(options?: CodexAppServerOptions);
+    sendTurn(text: string, options?: CodexTurnOptions): Promise<string>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    private ensureStarted;
+    private start;
+    private consumeStdout;
+    private send;
+    private runTurn;
+}

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

@@ -0,0 +1,305 @@
+import { spawn } from "node:child_process";
+import { l } from "../core/i18n.js";
+const DEFAULT_STARTUP_TIMEOUT_MS = 30_000;
+const DEFAULT_TURN_TIMEOUT_MS = 5 * 60_000;
+function snippet(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const flat = value.replaceAll("\n", " ").trim();
+    if (!flat) {
+        return undefined;
+    }
+    return flat.length > 80 ? `${flat.slice(0, 77)}…` : flat;
+}
+const singletons = new Map();
+const DEFAULT_KEY = "__default__";
+export function getSharedCodexAppServer(model) {
+    const key = model && model.length > 0 ? model : DEFAULT_KEY;
+    let session = singletons.get(key);
+    if (!session) {
+        session = new CodexAppServerSession(model ? { model } : {});
+        singletons.set(key, session);
+    }
+    return session;
+}
+export async function shutdownSharedCodexAppServer() {
+    const sessions = [...singletons.values()];
+    singletons.clear();
+    await Promise.all(sessions.map((session) => session.stop().catch(() => undefined)));
+}
+export class CodexAppServerSession {
+    child = null;
+    buffer = "";
+    nextId = 1;
+    pending = new Map();
+    notificationHandlers = new Set();
+    starting = null;
+    options;
+    exitReason = null;
+    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);
+        }
+        this.options = {
+            bin: options.bin || process.env.AGENT_SIN_CODEX_BIN || "codex",
+            args: baseArgs,
+            model,
+            startupTimeoutMs: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
+            turnTimeoutMs: options.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS,
+            onStderr: options.onStderr,
+        };
+    }
+    async sendTurn(text, options = {}) {
+        await this.ensureStarted();
+        const startResponse = (await this.send("thread/start", {
+            cwd: options.cwd,
+            ...(options.sandbox ? { sandbox: options.sandbox } : {}),
+            ...(options.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {}),
+        }));
+        const threadId = startResponse?.thread?.id;
+        if (!threadId) {
+            throw new Error("codex app-server: thread/start did not return a thread id");
+        }
+        return await this.runTurn(threadId, text, options);
+    }
+    async stop() {
+        if (!this.child) {
+            return;
+        }
+        const child = this.child;
+        this.child = null;
+        this.starting = null;
+        this.notificationHandlers.clear();
+        for (const pending of this.pending.values()) {
+            pending.reject(new Error("codex app-server: shutting down"));
+        }
+        this.pending.clear();
+        child.stdin.end();
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                child.kill("SIGTERM");
+            }, 1000);
+            child.once("exit", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+    }
+    isRunning() {
+        return this.child !== null && this.child.exitCode === null;
+    }
+    async ensureStarted() {
+        if (this.isRunning() && !this.starting) {
+            return;
+        }
+        if (this.starting) {
+            return this.starting;
+        }
+        this.starting = this.start().finally(() => {
+            this.starting = null;
+        });
+        await this.starting;
+    }
+    async start() {
+        const child = spawn(this.options.bin, this.options.args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.child = child;
+        this.exitReason = null;
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => this.consumeStdout(chunk));
+        child.stderr.on("data", (chunk) => {
+            if (this.options.onStderr) {
+                this.options.onStderr(chunk);
+            }
+        });
+        child.on("exit", (code, signal) => {
+            this.exitReason = `exited code=${code} signal=${signal}`;
+            const error = new Error(`codex app-server: ${this.exitReason}`);
+            for (const pending of this.pending.values()) {
+                pending.reject(error);
+            }
+            this.pending.clear();
+            this.notificationHandlers.clear();
+            this.child = null;
+        });
+        child.on("error", (error) => {
+            this.exitReason = `spawn error: ${error.message}`;
+            for (const pending of this.pending.values()) {
+                pending.reject(error);
+            }
+            this.pending.clear();
+        });
+        const initTimer = setTimeout(() => {
+            child.kill("SIGTERM");
+        }, this.options.startupTimeoutMs);
+        try {
+            await this.send("initialize", {
+                clientInfo: { name: "agent-sin", version: "0.1.0" },
+            });
+        }
+        finally {
+            clearTimeout(initTimer);
+        }
+    }
+    consumeStdout(chunk) {
+        this.buffer += chunk;
+        let newlineIndex;
+        while ((newlineIndex = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, newlineIndex);
+            this.buffer = this.buffer.slice(newlineIndex + 1);
+            if (!line.trim()) {
+                continue;
+            }
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (message.id !== undefined && this.pending.has(message.id)) {
+                const handler = this.pending.get(message.id);
+                this.pending.delete(message.id);
+                if (handler) {
+                    if (message.error) {
+                        handler.reject(new Error(`codex app-server error: ${message.error.message || JSON.stringify(message.error)}`));
+                    }
+                    else {
+                        handler.resolve(message.result);
+                    }
+                }
+                continue;
+            }
+            if (message.method) {
+                for (const handler of this.notificationHandlers) {
+                    try {
+                        handler(message.method, message.params);
+                    }
+                    catch {
+                        // Notification handlers should not throw, but we ignore if they do.
+                    }
+                }
+            }
+        }
+    }
+    send(method, params) {
+        if (!this.child) {
+            return Promise.reject(new Error("codex app-server: not running"));
+        }
+        return new Promise((resolve, reject) => {
+            const id = this.nextId;
+            this.nextId += 1;
+            this.pending.set(id, { resolve, reject });
+            const payload = JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} });
+            this.child.stdin.write(`${payload}\n`, (error) => {
+                if (error) {
+                    this.pending.delete(id);
+                    reject(error);
+                }
+            });
+        });
+    }
+    runTurn(threadId, text, options) {
+        return new Promise((resolve, reject) => {
+            let assistantText = "";
+            let settled = false;
+            const emit = (event) => {
+                if (!options.onProgress) {
+                    return;
+                }
+                try {
+                    options.onProgress(event);
+                }
+                catch {
+                    // Progress handlers must not throw; ignore.
+                }
+            };
+            const handler = (method, params) => {
+                if (settled || !params) {
+                    return;
+                }
+                const eventThreadId = params.threadId;
+                if (eventThreadId && eventThreadId !== threadId) {
+                    return;
+                }
+                if (method === "item/started" || method === "item/updated") {
+                    const item = params.item;
+                    if (item) {
+                        if (item.type === "agentMessage") {
+                            emit({ kind: "message", text: snippet(item.text) });
+                        }
+                        else if (item.type === "reasoning" || item.type === "thinking") {
+                            emit({ kind: "thinking", text: snippet(item.text) });
+                        }
+                        else if (item.type === "command" ||
+                            item.type === "command_execution" ||
+                            item.type === "tool_call" ||
+                            item.type === "tool_use") {
+                            emit({ kind: "tool", name: item.name || item.type, text: snippet(item.text) });
+                        }
+                        else if (item.type) {
+                            emit({ kind: "info", text: `${item.type}${item.name ? `: ${item.name}` : ""}` });
+                        }
+                    }
+                }
+                else if (method === "item/completed") {
+                    const item = params.item;
+                    if (item && item.type === "agentMessage" && typeof item.text === "string") {
+                        assistantText = item.text;
+                        emit({ kind: "message", text: snippet(item.text) });
+                    }
+                    else if (item && (item.type === "command" || item.type === "tool_call")) {
+                        emit({ kind: "tool", name: item.name || item.type, text: l("done", "完了") });
+                    }
+                }
+                else if (method === "turn/completed") {
+                    const turn = params.turn;
+                    if (turn && Array.isArray(turn.items)) {
+                        const fromTurn = turn.items
+                            .filter((entry) => entry && entry.type === "agentMessage" && typeof entry.text === "string")
+                            .map((entry) => entry.text)
+                            .join("\n");
+                        if (fromTurn) {
+                            assistantText = fromTurn;
+                        }
+                    }
+                    finish(true, undefined);
+                }
+                else if (method === "turn/failed" || method === "error") {
+                    const reason = JSON.stringify(params).slice(0, 400);
+                    finish(false, new Error(`codex app-server: turn failed: ${reason}`));
+                }
+            };
+            const finish = (ok, error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeout);
+                this.notificationHandlers.delete(handler);
+                if (ok) {
+                    resolve(assistantText);
+                }
+                else {
+                    reject(error || new Error("codex app-server: unknown failure"));
+                }
+            };
+            const timeout = setTimeout(() => {
+                finish(false, new Error(`codex app-server: turn timed out after ${this.options.turnTimeoutMs}ms`));
+            }, this.options.turnTimeoutMs);
+            this.notificationHandlers.add(handler);
+            this.send("turn/start", {
+                threadId,
+                input: [{ type: "text", text }],
+                ...(options.effort ? { effort: options.effort } : {}),
+            }).catch((sendError) => {
+                finish(false, sendError instanceof Error ? sendError : new Error(String(sendError)));
+            });
+        });
+    }
+}

package/dist/runtimes/python-runner.d.ts

@@ -0,0 +1,7 @@
+import { type SkillManifest } from "../core/skill-registry.js";
+import type { SkillInput } from "../skills-sdk/types.js";
+import type { SkillExecution } from "../core/runtime.js";
+import type { AppConfig } from "../core/config.js";
+export declare function candidatePythonInterpreters(config: AppConfig, platform?: NodeJS.Platform): string[];
+export declare function resolvePythonInterpreter(config: AppConfig): string;
+export declare function runPythonSkill(config: AppConfig, manifest: SkillManifest, input: SkillInput): Promise<SkillExecution>;

package/dist/runtimes/python-runner.js

@@ -0,0 +1,302 @@
+import { spawn } from "node:child_process";
+import { statSync } from "node:fs";
+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";
+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 CTX_LOG_PATTERN = /^\[(info|warn|error)\]\s+([\s\S]*)$/;
+export function candidatePythonInterpreters(config, platform = process.platform) {
+    const venvDir = path.join(config.workspace, ".venv");
+    const fallback = platform === "win32" ? "python" : "python3";
+    if (platform === "win32") {
+        return [
+            path.join(venvDir, "Scripts", "python.exe"),
+            path.join(venvDir, "Scripts", "python"),
+            fallback,
+        ];
+    }
+    return [path.join(venvDir, "bin", "python"), fallback];
+}
+export function resolvePythonInterpreter(config) {
+    if (process.env.AGENT_SIN_PYTHON) {
+        return process.env.AGENT_SIN_PYTHON;
+    }
+    const candidates = candidatePythonInterpreters(config);
+    for (const candidate of candidates.slice(0, -1)) {
+        try {
+            const info = statSync(candidate);
+            if (info.isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // Candidate not present; try the next one.
+        }
+    }
+    return candidates[candidates.length - 1] || "python3";
+}
+export async function runPythonSkill(config, manifest, input) {
+    const entry = await resolveSkillEntryPath(manifest);
+    const python = resolvePythonInterpreter(config);
+    const runtimePolicy = JSON.stringify({
+        ai_steps: manifest.ai_steps || [],
+        memory: manifest.memory || {},
+    });
+    const child = spawn(python, ["-c", runnerSource(), entry, manifest.handler, runtimePolicy], {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+            ...process.env,
+            PYTHONDONTWRITEBYTECODE: "1",
+        },
+    });
+    const stdout = [];
+    const stderrLines = [];
+    const ctxLogs = [];
+    let stderrBuffer = "";
+    child.stdin.on("error", () => { });
+    child.stdout.on("data", (chunk) => stdout.push(chunk));
+    child.stderr.on("data", (chunk) => {
+        stderrBuffer += chunk.toString("utf8");
+        let newlineIndex;
+        while ((newlineIndex = stderrBuffer.indexOf("\n")) >= 0) {
+            const line = stderrBuffer.slice(0, newlineIndex);
+            stderrBuffer = stderrBuffer.slice(newlineIndex + 1);
+            handleStderrLine(line);
+        }
+    });
+    function handleStderrLine(line) {
+        if (line.startsWith(AI_REQUEST_PREFIX)) {
+            const payloadJson = line.slice(AI_REQUEST_PREFIX.length);
+            handleAiRequest(payloadJson).catch((error) => {
+                stderrLines.push(`[ai-error] ${error instanceof Error ? error.message : String(error)}`);
+            });
+            return;
+        }
+        if (line.startsWith(NOTIFY_REQUEST_PREFIX)) {
+            const payloadJson = line.slice(NOTIFY_REQUEST_PREFIX.length);
+            handleNotifyRequest(payloadJson).catch((error) => {
+                stderrLines.push(`[notify-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] });
+            return;
+        }
+        stderrLines.push(line);
+    }
+    async function handleAiRequest(payloadJson) {
+        let request;
+        try {
+            request = JSON.parse(payloadJson);
+        }
+        catch (error) {
+            child.stdin.write(`${AI_RESPONSE_PREFIX}${JSON.stringify({ id: "?", error: `Invalid AI request JSON: ${String(error)}` })}\n`);
+            return;
+        }
+        try {
+            const response = await getAiProvider()(config, {
+                model_id: request.model_id,
+                messages: request.messages,
+            });
+            child.stdin.write(`${AI_RESPONSE_PREFIX}${JSON.stringify({ id: request.id, ok: true, response })}\n`);
+        }
+        catch (error) {
+            child.stdin.write(`${AI_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 {
+            request = JSON.parse(payloadJson);
+        }
+        catch (error) {
+            child.stdin.write(`${NOTIFY_RESPONSE_PREFIX}${JSON.stringify({ id: "?", ok: false, detail: `Invalid notify request JSON: ${String(error)}` })}\n`);
+            return;
+        }
+        try {
+            const args = request.args || {};
+            const result = await runNotify({
+                title: String(args.title ?? ""),
+                body: String(args.body ?? ""),
+                subtitle: typeof args.subtitle === "string" ? args.subtitle : undefined,
+                sound: Boolean(args.sound),
+                channel: typeof args.channel === "string" ? args.channel : undefined,
+                to: typeof args.to === "string" ? args.to : undefined,
+                discordThreadId: typeof args.discordThreadId === "string" ? args.discordThreadId : undefined,
+                telegramThreadId: typeof args.telegramThreadId === "string" ? args.telegramThreadId : undefined,
+            });
+            child.stdin.write(`${NOTIFY_RESPONSE_PREFIX}${JSON.stringify({ id: request.id, ok: result.ok, channel: result.channel, detail: result.detail })}\n`);
+        }
+        catch (error) {
+            child.stdin.write(`${NOTIFY_RESPONSE_PREFIX}${JSON.stringify({
+                id: request.id,
+                ok: false,
+                detail: error instanceof Error ? error.message : String(error),
+            })}\n`);
+        }
+    }
+    child.stdin.write(JSON.stringify(input));
+    child.stdin.write("\n");
+    const code = await new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", resolve);
+    });
+    if (stderrBuffer) {
+        handleStderrLine(stderrBuffer);
+        stderrBuffer = "";
+    }
+    const err = stderrLines.join("\n").trim();
+    const out = Buffer.concat(stdout).toString("utf8").trim();
+    if (code !== 0) {
+        throw new Error(err || `Python skill exited with code ${code}`);
+    }
+    try {
+        const parsed = JSON.parse(out);
+        if (isRunnerEnvelope(parsed)) {
+            return {
+                result: parsed.result,
+                memory_updates: parsed.memory_updates,
+                logs: ctxLogs,
+            };
+        }
+        return { result: parsed, logs: ctxLogs };
+    }
+    catch {
+        throw new Error(`Python skill did not return valid JSON${err ? `: ${err}` : ""}`);
+    }
+}
+function isRunnerEnvelope(value) {
+    return Boolean(value) && typeof value === "object" && value.__agent_sin_runner === 1;
+}
+function runnerSource() {
+    return String.raw `
+import asyncio
+import importlib.util
+import json
+import sys
+import uuid
+from datetime import datetime, timezone
+
+skill_path = sys.argv[1]
+handler_name = sys.argv[2]
+policy = json.loads(sys.argv[3])
+payload = json.loads(sys.stdin.readline())
+allowed_ai_steps = {step.get("id"): step for step in policy.get("ai_steps", [])}
+memory_policy = policy.get("memory") or {}
+
+class Log:
+    def info(self, message):
+        print(f"[info] {message}", file=sys.stderr, flush=True)
+    def warn(self, message):
+        print(f"[warn] {message}", file=sys.stderr, flush=True)
+    def error(self, message):
+        print(f"[error] {message}", file=sys.stderr, flush=True)
+
+class AI:
+    async def run(self, step_id, ai_payload):
+        step = allowed_ai_steps.get(step_id)
+        if not step:
+            raise RuntimeError(f"AI step is not defined for this skill: {step_id}")
+        model_id = step.get("model") or ""
+        if not model_id:
+            raise RuntimeError(f"AI step has no model: {step_id}")
+        prompt = ai_payload if isinstance(ai_payload, str) else json.dumps(ai_payload, ensure_ascii=False)
+        messages = [
+            {"role": "system", "content": f'You are an AI step "{step_id}" of an Agent-Sin skill. Purpose: ' + (step.get("purpose") or "")},
+            {"role": "user", "content": prompt},
+        ]
+        request_id = str(uuid.uuid4())
+        request = {"id": request_id, "step_id": step_id, "model_id": model_id, "messages": messages}
+        print("AGENT_SIN_AI_REQUEST::" + json.dumps(request, ensure_ascii=False), file=sys.stderr, flush=True)
+        line = sys.stdin.readline()
+        if not line:
+            raise RuntimeError("AI provider channel closed")
+        marker = "AGENT_SIN_AI_RESPONSE::"
+        idx = line.find(marker)
+        if idx < 0:
+            raise RuntimeError(f"Unexpected AI response: {line.strip()}")
+        envelope = json.loads(line[idx + len(marker):])
+        if not envelope.get("ok"):
+            error_message = envelope.get("error") or "AI provider error"
+            if step.get("optional"):
+                return {"status": "skipped", "step_id": step_id, "reason": error_message, "payload": ai_payload}
+            raise RuntimeError(error_message)
+        response = envelope.get("response") or {}
+        return {
+            "status": "ok",
+            "step_id": step_id,
+            "model_id": response.get("model_id"),
+            "provider": response.get("provider"),
+            "text": response.get("text", ""),
+        }
+
+class Memory:
+    def __init__(self):
+        self.values = dict(payload.get("memory") or {})
+        self.updates = {}
+    async def get(self, key):
+        if not memory_policy.get("read"):
+            return None
+        return self.values.get(key)
+    async def set(self, key, value):
+        if not memory_policy.get("write"):
+            raise RuntimeError("Memory write is not allowed for this skill")
+        self.values[key] = value
+        self.updates[key] = value
+        return True
+
+async def notify_call(args):
+    if not isinstance(args, dict):
+        raise RuntimeError("ctx.notify requires a dict argument")
+    request_id = str(uuid.uuid4())
+    request = {"id": request_id, "args": args}
+    print("AGENT_SIN_NOTIFY_REQUEST::" + json.dumps(request, ensure_ascii=False), file=sys.stderr, flush=True)
+    line = sys.stdin.readline()
+    if not line:
+        raise RuntimeError("Notify channel closed")
+    marker = "AGENT_SIN_NOTIFY_RESPONSE::"
+    idx = line.find(marker)
+    if idx < 0:
+        raise RuntimeError(f"Unexpected notify response: {line.strip()}")
+    envelope = json.loads(line[idx + len(marker):])
+    return {
+        "ok": bool(envelope.get("ok")),
+        "channel": envelope.get("channel"),
+        "detail": envelope.get("detail"),
+    }
+
+class Ctx:
+    def __init__(self):
+        self.log = Log()
+        self.ai = AI()
+        self.memory = Memory()
+    def now(self):
+        return datetime.now(timezone.utc).isoformat()
+    async def notify(self, args):
+        return await notify_call(args)
+
+spec = importlib.util.spec_from_file_location("agent_sin_skill", skill_path)
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+handler = getattr(module, handler_name)
+ctx = Ctx()
+result = handler(ctx, payload)
+if asyncio.iscoroutine(result):
+    result = asyncio.run(result)
+print(json.dumps({
+    "__agent_sin_runner": 1,
+    "result": result,
+    "memory_updates": ctx.memory.updates
+}, ensure_ascii=False))
+`;
+}

package/dist/runtimes/typescript-runner.d.ts

@@ -0,0 +1,5 @@
+import { type SkillManifest } from "../core/skill-registry.js";
+import type { SkillInput } from "../skills-sdk/types.js";
+import type { SkillExecution } from "../core/runtime.js";
+import type { AppConfig } from "../core/config.js";
+export declare function runTypeScriptSkill(config: AppConfig, manifest: SkillManifest, input: SkillInput): Promise<SkillExecution>;