@alejandroroman/agent-kit 0.1.0

package/dist/agent/loop.js

@@ -0,0 +1,195 @@
+import { complete } from "../llm/index.js";
+import { completeWithFallback } from "../llm/fallback.js";
+import { extractText } from "../llm/types.js";
+import { nanoid } from "nanoid";
+import { toolToDefinition } from "../tools/types.js";
+import { compactMessages, estimateTotalTokens } from "../session/compaction.js";
+import { createLogger } from "../logger.js";
+import { truncate } from "../text.js";
+const log = createLogger("agent");
+export async function runAgentLoop(initialMessages, config) {
+    const messages = [...initialMessages];
+    const registry = config.toolRegistry;
+    const staticTools = config.tools ?? [];
+    const maxIterations = config.maxIterations ?? 20;
+    const label = config.label ?? "main";
+    const loopStart = Date.now();
+    const currentTools = registry
+        ? registry.list().map((name) => registry.resolve([name])[0])
+        : staticTools;
+    const toolNames = currentTools.map((t) => t.name);
+    log.info({ label, model: config.model, tools: toolNames.length, toolNames, maxIterations, messages: initialMessages.length }, "loop start");
+    const runId = nanoid();
+    const agentName = config.agentName ?? config.label ?? "main";
+    const totalUsage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
+        reasoningTokens: 0,
+    };
+    let toolCallsCount = 0;
+    let didCompact = false;
+    for (let i = 0; i < maxIterations; i++) {
+        const iteration = i + 1;
+        // Rebuild tool definitions each iteration (skills may register new tools mid-loop)
+        const iterTools = registry
+            ? registry.list().map((name) => registry.resolve([name])[0])
+            : staticTools;
+        const toolMap = new Map(iterTools.map((t) => [t.name, t]));
+        const toolDefs = iterTools.map(toolToDefinition);
+        // Compact conversation if it exceeds the token threshold (one-shot: only once per loop)
+        if (!didCompact && config.compactionThreshold) {
+            const estimated = estimateTotalTokens(messages);
+            if (estimated > config.compactionThreshold) {
+                log.info({ label, iteration, estimated, threshold: config.compactionThreshold }, "compacting messages");
+                try {
+                    const compacted = await compactMessages(messages, config.model, config.compactionThreshold);
+                    messages.length = 0;
+                    messages.push(...compacted);
+                    didCompact = true;
+                }
+                catch (err) {
+                    const isBug = err instanceof TypeError || err instanceof ReferenceError || err instanceof SyntaxError || err instanceof RangeError;
+                    if (isBug) {
+                        log.fatal({ err, label, iteration }, "compaction bug — programming error");
+                        throw err;
+                    }
+                    log.warn({ err, label, iteration }, "compaction failed, proceeding with full context");
+                }
+            }
+        }
+        const response = await completeWithFallback(config.model, config.fallbacks ?? [], messages, {
+            systemPrompt: config.systemPrompt,
+            tools: toolDefs.length > 0 ? toolDefs : undefined,
+        }, complete);
+        totalUsage.inputTokens += response.usage.inputTokens;
+        totalUsage.outputTokens += response.usage.outputTokens;
+        totalUsage.cacheCreationTokens += response.usage.cacheCreationTokens;
+        totalUsage.cacheReadTokens += response.usage.cacheReadTokens;
+        totalUsage.reasoningTokens += response.usage.reasoningTokens;
+        if (config.usageStore) {
+            try {
+                config.usageStore.recordCall({
+                    runId,
+                    agentName,
+                    provider: response.model.split(":")[0],
+                    model: response.model,
+                    usage: response.usage,
+                    stopReason: response.stopReason,
+                    latencyMs: response.latencyMs,
+                });
+            }
+            catch (err) {
+                log.error({ err, runId }, "failed to record LLM call");
+            }
+        }
+        log.debug({ label, iteration, model: config.model, stopReason: response.stopReason, inputTokens: response.usage.inputTokens, outputTokens: response.usage.outputTokens }, "iteration complete");
+        messages.push({ role: "assistant", content: response.content });
+        if (response.stopReason !== "tool_use") {
+            let text = extractText(response.content);
+            // If the final turn has no text (e.g. LLM said everything alongside a tool call
+            // in a prior turn), scan backward for the last assistant text.
+            if (!text) {
+                for (let j = messages.length - 2; j >= 0; j--) {
+                    const msg = messages[j];
+                    if (msg.role === "assistant") {
+                        const found = extractText(msg.content);
+                        if (found) {
+                            text = found;
+                            break;
+                        }
+                    }
+                }
+            }
+            const elapsed = Date.now() - loopStart;
+            if (config.usageStore) {
+                try {
+                    config.usageStore.recordRun({
+                        id: runId,
+                        agentName,
+                        source: config.source ?? "unknown",
+                        model: config.model,
+                        usage: totalUsage,
+                        iterations: iteration,
+                        toolCallsCount,
+                        durationMs: elapsed,
+                    });
+                }
+                catch (err) {
+                    log.error({ err, runId }, "failed to record agent run");
+                }
+            }
+            log.info({ label, stopReason: response.stopReason, iterations: iteration, inputTokens: totalUsage.inputTokens, outputTokens: totalUsage.outputTokens, elapsed }, "loop end");
+            return {
+                text,
+                messages,
+                usage: totalUsage,
+            };
+        }
+        const toolCalls = response.content.filter((b) => b.type === "tool_call");
+        toolCallsCount += toolCalls.length;
+        for (const call of toolCalls) {
+            log.debug({ label, iteration, tool: call.name, args: truncate(JSON.stringify(call.arguments), 200) }, "tool call");
+            const tool = toolMap.get(call.name);
+            let result;
+            if (!tool) {
+                log.warn({ label, iteration, tool: call.name }, "LLM called unknown tool");
+                result = `Error: unknown tool "${call.name}"`;
+            }
+            else {
+                const toolStart = Date.now();
+                try {
+                    result = await tool.execute(call.arguments);
+                    const toolElapsed = Date.now() - toolStart;
+                    log.debug({ label, iteration, tool: call.name, resultLength: result.length, snippet: truncate(result, 150), elapsed: toolElapsed }, "tool result");
+                }
+                catch (err) {
+                    const isBug = err instanceof TypeError || err instanceof ReferenceError || err instanceof SyntaxError || err instanceof RangeError;
+                    if (isBug) {
+                        log.fatal({ err, tool: call.name, label, iteration }, "tool bug — programming error");
+                    }
+                    else {
+                        log.error({ err, tool: call.name, label, iteration }, "tool execution failed");
+                    }
+                    result = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            }
+            const maxResultSize = config.maxToolResultSize ?? 8192;
+            if (result.length > maxResultSize) {
+                const originalLength = result.length;
+                result = result.slice(0, maxResultSize) + `\n\n[Output truncated from ${originalLength} to ${maxResultSize} characters]`;
+                log.debug({ label, iteration, tool: call.name, originalLength, maxResultSize }, "tool result truncated");
+            }
+            messages.push({
+                role: "tool_result",
+                tool_call_id: call.id,
+                content: result,
+            });
+        }
+    }
+    const elapsed = Date.now() - loopStart;
+    if (config.usageStore) {
+        try {
+            config.usageStore.recordRun({
+                id: runId,
+                agentName,
+                source: config.source ?? "unknown",
+                model: config.model,
+                usage: totalUsage,
+                iterations: maxIterations,
+                toolCallsCount,
+                durationMs: elapsed,
+            });
+        }
+        catch (err) {
+            log.error({ err, runId }, "failed to record agent run");
+        }
+    }
+    log.warn({ label, maxIterations, inputTokens: totalUsage.inputTokens, outputTokens: totalUsage.outputTokens, elapsed }, "max iterations reached");
+    return {
+        text: "[Agent reached maximum iterations]",
+        messages,
+        usage: totalUsage,
+    };
+}

package/dist/agent/setup.d.ts

@@ -0,0 +1,6 @@
+import { SessionManager } from "../session/manager.js";
+export interface AgentSession {
+    soul: string | undefined;
+    session: SessionManager;
+}
+export declare function setupAgentSession(dataDir: string, agentName: string, sessionId: string): AgentSession;

package/dist/agent/setup.js

@@ -0,0 +1,11 @@
+import * as path from "path";
+import { loadSoul } from "./soul.js";
+import { SessionManager } from "../session/manager.js";
+export function setupAgentSession(dataDir, agentName, sessionId) {
+    const agentDir = path.join(dataDir, "agents", agentName);
+    const sessionDir = path.join(agentDir, "sessions");
+    return {
+        soul: loadSoul(agentDir),
+        session: new SessionManager(sessionDir, sessionId),
+    };
+}

package/dist/agent/soul.d.ts

@@ -0,0 +1 @@
+export declare function loadSoul(agentDir: string): string | undefined;

package/dist/agent/soul.js

@@ -0,0 +1,8 @@
+import * as fs from "fs";
+import * as path from "path";
+export function loadSoul(agentDir) {
+    const soulPath = path.join(agentDir, "SOUL.md");
+    if (!fs.existsSync(soulPath))
+        return undefined;
+    return fs.readFileSync(soulPath, "utf-8");
+}

package/dist/agent/types.d.ts

@@ -0,0 +1,23 @@
+import type { Tool } from "../tools/types.js";
+import type { ToolRegistry } from "../tools/registry.js";
+import type { TokenUsage } from "../llm/types.js";
+import type { UsageStore } from "../usage/store.js";
+export interface AgentConfig {
+    model: string;
+    fallbacks?: string[];
+    systemPrompt?: string;
+    tools?: Tool[];
+    toolRegistry?: ToolRegistry;
+    maxIterations?: number;
+    label?: string;
+    agentName?: string;
+    usageStore?: UsageStore;
+    source?: string;
+    maxToolResultSize?: number;
+    compactionThreshold?: number;
+}
+export interface AgentResult {
+    text: string;
+    messages: import("../llm/types.js").Message[];
+    usage: TokenUsage;
+}

package/dist/agent/types.js

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

package/dist/api/agents.d.ts

@@ -0,0 +1,2 @@
+import { type ApiContext, type RouteHandler } from "./types.js";
+export declare function agentRoutes(ctx: ApiContext): Record<string, RouteHandler>;

package/dist/api/agents.js

@@ -0,0 +1,43 @@
+import { sendJson, sendError } from "./types.js";
+export function agentRoutes(ctx) {
+    return {
+        "GET /api/agents": (_url, _req, res) => {
+            const agents = Object.entries(ctx.config.agents).map(([name, def]) => ({
+                name,
+                displayName: def.displayName ?? null,
+                emoji: def.emoji ?? null,
+                avatar: def.avatar ?? null,
+                model: def.model ?? ctx.config.defaults.model,
+                tools: def.tools,
+                skills: def.skills,
+                spawnOnly: def.spawn_only,
+                canSpawn: def.can_spawn,
+                maxIterations: def.maxIterations ?? ctx.config.defaults.maxIterations,
+                slack: def.slack ?? null,
+            }));
+            sendJson(res, agents);
+        },
+        "GET /api/agents/:name": (url, _req, res) => {
+            const name = url.pathname.split("/")[3];
+            const def = ctx.config.agents[name];
+            if (!def) {
+                sendError(res, 404, "agent not found");
+                return;
+            }
+            sendJson(res, {
+                name,
+                displayName: def.displayName ?? null,
+                emoji: def.emoji ?? null,
+                avatar: def.avatar ?? null,
+                model: def.model ?? ctx.config.defaults.model,
+                tools: def.tools,
+                skills: def.skills,
+                spawnOnly: def.spawn_only,
+                canSpawn: def.can_spawn,
+                maxIterations: def.maxIterations ?? ctx.config.defaults.maxIterations,
+                slack: def.slack ?? null,
+                sandbox: def.sandbox ?? ctx.config.defaults.sandbox ?? null,
+            });
+        },
+    };
+}

package/dist/api/config.d.ts

@@ -0,0 +1,2 @@
+import { type ApiContext, type RouteHandler } from "./types.js";
+export declare function configRoutes(ctx: ApiContext): Record<string, RouteHandler>;

package/dist/api/config.js

@@ -0,0 +1,20 @@
+import * as fs from "fs";
+import { sendJson } from "./types.js";
+export function configRoutes(ctx) {
+    return {
+        "GET /api/config": (_url, _req, res) => {
+            const raw = fs.readFileSync(ctx.configPath, "utf-8");
+            const config = JSON.parse(raw);
+            sendJson(res, config);
+        },
+        "GET /api/config/models": (_url, _req, res) => {
+            const models = (ctx.config.models ?? []).map((m) => ({
+                alias: m.alias,
+                provider: m.model.split(":")[0],
+                model: m.model,
+                isDefault: m.alias === ctx.config.defaults.model,
+            }));
+            sendJson(res, models);
+        },
+    };
+}

package/dist/api/cron.d.ts

@@ -0,0 +1,2 @@
+import { type ApiContext, type RouteHandler } from "./types.js";
+export declare function cronRoutes(ctx: ApiContext): Record<string, RouteHandler>;

package/dist/api/cron.js

@@ -0,0 +1,15 @@
+import { sendJson } from "./types.js";
+export function cronRoutes(ctx) {
+    return {
+        "GET /api/cron": (_url, _req, res) => {
+            const jobs = ctx.config.cron.map((job) => ({
+                id: job.id,
+                agent: job.agent,
+                schedule: job.schedule,
+                prompt: job.prompt,
+                enabled: job.enabled,
+            }));
+            sendJson(res, jobs);
+        },
+    };
+}

package/dist/api/health.d.ts

@@ -0,0 +1,2 @@
+import { type ApiContext, type RouteHandler } from "./types.js";
+export declare function healthRoutes(_ctx: ApiContext): Record<string, RouteHandler>;

package/dist/api/health.js

@@ -0,0 +1,8 @@
+import { sendJson } from "./types.js";
+export function healthRoutes(_ctx) {
+    return {
+        "GET /api/health": (_url, _req, res) => {
+            sendJson(res, { status: "ok", timestamp: new Date().toISOString() });
+        },
+    };
+}

package/dist/api/logs.d.ts

@@ -0,0 +1,5 @@
+import type { RouteHandler } from "./types.js";
+export declare function addLogListener(res: import("http").ServerResponse): void;
+export declare function removeLogListener(res: import("http").ServerResponse): void;
+export declare function broadcastLog(data: string): void;
+export declare function logRoutes(): Record<string, RouteHandler>;

package/dist/api/logs.js

@@ -0,0 +1,28 @@
+const clients = new Set();
+export function addLogListener(res) {
+    clients.add(res);
+}
+export function removeLogListener(res) {
+    clients.delete(res);
+}
+export function broadcastLog(data) {
+    for (const client of clients) {
+        client.write(`data: ${data}\n\n`);
+    }
+}
+export function logRoutes() {
+    return {
+        "GET /api/logs/stream": (_url, req, res) => {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            res.write(`data: ${JSON.stringify({ type: "connected", timestamp: new Date().toISOString() })}\n\n`);
+            addLogListener(res);
+            req.on("close", () => {
+                removeLogListener(res);
+            });
+        },
+    };
+}

package/dist/api/router.d.ts

@@ -0,0 +1,6 @@
+import { type ApiContext } from "./types.js";
+export interface ApiServer {
+    start(): Promise<number>;
+    stop(): Promise<void>;
+}
+export declare function createApiServer(ctx: ApiContext, port: number): ApiServer;

package/dist/api/router.js

@@ -0,0 +1,80 @@
+import * as http from "http";
+import { sendError } from "./types.js";
+import { healthRoutes } from "./health.js";
+import { sessionRoutes } from "./sessions.js";
+import { agentRoutes } from "./agents.js";
+import { configRoutes } from "./config.js";
+import { cronRoutes } from "./cron.js";
+import { logRoutes } from "./logs.js";
+import { usageRoutes } from "./usage.js";
+import { createLogger } from "../logger.js";
+const log = createLogger("api");
+function parseRouteKey(key) {
+    const [method, path] = key.split(" ");
+    // Convert :param segments to regex groups
+    const regexStr = "^" + path.replace(/:([^/]+)/g, "([^/]+)") + "$";
+    return { method, pattern: new RegExp(regexStr) };
+}
+export function createApiServer(ctx, port) {
+    // Collect routes from all modules
+    const routeHandlers = {
+        ...healthRoutes(ctx),
+        ...sessionRoutes(ctx),
+        ...agentRoutes(ctx),
+        ...configRoutes(ctx),
+        ...cronRoutes(ctx),
+        ...logRoutes(),
+    };
+    // If usage store exists, add usage routes
+    if (ctx.usageStore) {
+        Object.assign(routeHandlers, usageRoutes(ctx.usageStore));
+    }
+    const routes = Object.entries(routeHandlers).map(([key, handler]) => {
+        const { method, pattern } = parseRouteKey(key);
+        return { method, pattern, handler };
+    });
+    const server = http.createServer((req, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        res.setHeader("Content-Type", "application/json");
+        const url = new URL(req.url ?? "/", `http://localhost`);
+        const method = req.method ?? "GET";
+        const matched = routes.find((r) => r.method === method && r.pattern.test(url.pathname));
+        if (matched) {
+            try {
+                matched.handler(url, req, res);
+            }
+            catch (err) {
+                log.error({ err, path: url.pathname }, "API error");
+                sendError(res, 500, "internal server error");
+            }
+        }
+        else {
+            sendError(res, 404, "not found");
+        }
+    });
+    return {
+        start() {
+            return new Promise((resolve, reject) => {
+                server.once("error", reject);
+                server.listen(port, () => {
+                    const addr = server.address();
+                    const actualPort = typeof addr === "object" && addr ? addr.port : port;
+                    log.info({ port: actualPort }, "API server started");
+                    resolve(actualPort);
+                });
+            });
+        },
+        stop() {
+            return new Promise((resolve, reject) => {
+                server.close((err) => (err ? reject(err) : resolve()));
+            });
+        },
+    };
+}

package/dist/api/sessions.d.ts

@@ -0,0 +1,2 @@
+import { type ApiContext, type RouteHandler } from "./types.js";
+export declare function sessionRoutes(ctx: ApiContext): Record<string, RouteHandler>;

package/dist/api/sessions.js

@@ -0,0 +1,67 @@
+import * as fs from "fs";
+import * as path from "path";
+import { sendJson, sendError } from "./types.js";
+export function sessionRoutes(ctx) {
+    return {
+        "GET /api/sessions": (url, _req, res) => {
+            const agentsDir = path.join(ctx.dataDir, "agents");
+            if (!fs.existsSync(agentsDir)) {
+                sendJson(res, { total: 0, sessions: [] });
+                return;
+            }
+            const agentFilter = url.searchParams.get("agent") ?? undefined;
+            const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+            const offset = parseInt(url.searchParams.get("offset") ?? "0", 10);
+            const sessions = [];
+            const agentDirs = fs.readdirSync(agentsDir);
+            for (const agent of agentDirs) {
+                if (agentFilter && agent !== agentFilter)
+                    continue;
+                const agentDir = path.join(agentsDir, agent);
+                if (!fs.statSync(agentDir).isDirectory())
+                    continue;
+                const files = fs.readdirSync(agentDir).filter((f) => f.endsWith(".jsonl"));
+                for (const file of files) {
+                    const filePath = path.join(agentDir, file);
+                    const stat = fs.statSync(filePath);
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    const lines = content.split("\n").filter((l) => l.trim());
+                    sessions.push({
+                        agent,
+                        sessionId: file.replace(".jsonl", ""),
+                        messageCount: lines.length,
+                        sizeBytes: stat.size,
+                        lastModified: stat.mtime.toISOString(),
+                    });
+                }
+            }
+            sessions.sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime());
+            const page = sessions.slice(offset, offset + limit);
+            sendJson(res, { total: sessions.length, sessions: page });
+        },
+        "GET /api/sessions/:agent/:id": (url, _req, res) => {
+            const parts = url.pathname.split("/");
+            const agent = parts[3];
+            const id = parts[4];
+            const filePath = path.join(ctx.dataDir, "agents", agent, `${id}.jsonl`);
+            if (!fs.existsSync(filePath)) {
+                sendError(res, 404, "session not found");
+                return;
+            }
+            const content = fs.readFileSync(filePath, "utf-8");
+            const messages = content
+                .split("\n")
+                .filter((l) => l.trim())
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter(Boolean);
+            sendJson(res, { agent, sessionId: id, messages });
+        },
+    };
+}

package/dist/api/types.d.ts

@@ -0,0 +1,12 @@
+import type { Config } from "../config/schema.js";
+import type { UsageStore } from "../usage/store.js";
+export interface ApiContext {
+    config: Config;
+    configPath: string;
+    usageStore?: UsageStore;
+    dataDir: string;
+    memoryDbPath?: string;
+}
+export type RouteHandler = (url: URL, req: import("http").IncomingMessage, res: import("http").ServerResponse) => void;
+export declare function sendJson(res: import("http").ServerResponse, data: unknown, status?: number): void;
+export declare function sendError(res: import("http").ServerResponse, status: number, message: string): void;

package/dist/api/types.js

@@ -0,0 +1,13 @@
+export function sendJson(res, data, status = 200) {
+    if (res.headersSent)
+        return;
+    const body = JSON.stringify(data);
+    res.writeHead(status);
+    res.end(body);
+}
+export function sendError(res, status, message) {
+    if (res.headersSent)
+        return;
+    res.writeHead(status);
+    res.end(JSON.stringify({ error: message }));
+}

package/dist/api/usage.d.ts

@@ -0,0 +1,3 @@
+import type { UsageStore } from "../usage/store.js";
+import { type RouteHandler } from "./types.js";
+export declare function usageRoutes(store: UsageStore): Record<string, RouteHandler>;

package/dist/api/usage.js

@@ -0,0 +1,50 @@
+import { sendJson, sendError } from "./types.js";
+import { GROUP_BY_VALUES } from "../usage/types.js";
+const VALID_GROUP_BY = new Set(GROUP_BY_VALUES);
+function parseIntParam(val) {
+    if (val === null)
+        return undefined;
+    const n = parseInt(val, 10);
+    return isNaN(n) || n < 0 ? undefined : n;
+}
+export function usageRoutes(store) {
+    return {
+        "GET /api/usage/calls": (url, _req, res) => {
+            const data = store.getCalls({
+                model: url.searchParams.get("model") ?? undefined,
+                agentName: url.searchParams.get("agent") ?? undefined,
+                runId: url.searchParams.get("run_id") ?? undefined,
+                from: url.searchParams.get("from") ?? undefined,
+                to: url.searchParams.get("to") ?? undefined,
+                limit: parseIntParam(url.searchParams.get("limit")),
+                offset: parseIntParam(url.searchParams.get("offset")),
+            });
+            sendJson(res, data);
+        },
+        "GET /api/usage/runs": (url, _req, res) => {
+            const data = store.getRuns({
+                agentName: url.searchParams.get("agent") ?? undefined,
+                source: url.searchParams.get("source") ?? undefined,
+                model: url.searchParams.get("model") ?? undefined,
+                from: url.searchParams.get("from") ?? undefined,
+                to: url.searchParams.get("to") ?? undefined,
+                limit: parseIntParam(url.searchParams.get("limit")),
+                offset: parseIntParam(url.searchParams.get("offset")),
+            });
+            sendJson(res, data);
+        },
+        "GET /api/usage/summary": (url, _req, res) => {
+            const groupByParam = url.searchParams.get("group_by");
+            if (groupByParam && !VALID_GROUP_BY.has(groupByParam)) {
+                sendError(res, 400, "Invalid group_by value. Must be one of: model, agent, source, day");
+                return;
+            }
+            const data = store.getSummary({
+                from: url.searchParams.get("from") ?? undefined,
+                to: url.searchParams.get("to") ?? undefined,
+                groupBy: groupByParam ?? undefined,
+            });
+            sendJson(res, data);
+        },
+    };
+}