@baobox/sdk 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,53 +1,121 @@
-// @baobox/sdk — thin HTTP client for the BaoBox runtime.
-// No business logic here — everything smart lives server-side. This file
-// is ~300 lines on purpose; if it grows past ~500, something that belongs
-// in the runtime has leaked out.
 import { BaoBoxError } from "./errors.js";
 export { BaoBoxError } from "./errors.js";
 export class BaoBoxClient {
     endpoint;
     apiKey;
+    adminSecret;
     fetch;
     timeoutMs;
-    // `admin` and `events` are pseudo-namespaces — just method bundles so
-    // call sites read as `bb.admin.skills.upsert(...)` rather than a flat
-    // `bb.upsertSkill(...)`. Matches Tech Arch §4.2.
+    health;
     admin;
     sessions;
+    skills;
+    tools;
+    eval;
     events;
     constructor(opts) {
         if (!opts.endpoint)
             throw new Error("BaoBoxClient: endpoint required");
-        if (!opts.apiKey)
-            throw new Error("BaoBoxClient: apiKey required");
+        if (!opts.apiKey && !opts.adminSecret) {
+            throw new Error("BaoBoxClient: apiKey or adminSecret required");
+        }
         this.endpoint = opts.endpoint.replace(/\/+$/, "");
-        this.apiKey = opts.apiKey;
-        this.fetch = opts.fetch ?? globalThis.fetch;
+        this.apiKey = opts.apiKey ?? null;
+        this.adminSecret = opts.adminSecret ?? null;
+        const rawFetch = opts.fetch ?? globalThis.fetch;
+        this.fetch = rawFetch.bind(globalThis);
         this.timeoutMs = opts.timeoutMs ?? 30_000;
+        this.health = {
+            get: () => this.getHealth(),
+        };
         this.admin = {
+            keys: {
+                list: () => this.listApiKeys(),
+                create: (req) => this.createApiKey(req),
+                delete: (id) => this.deleteApiKey(id),
+            },
+            stats: {
+                get: (req) => this.getAdminStats(req),
+            },
+            logs: {
+                list: (req) => this.listAdminLogs(req),
+            },
+            tasks: {
+                list: () => this.listScheduledTasks(),
+                create: (req) => this.createScheduledTask(req),
+                update: (id, req) => this.updateScheduledTask(id, req),
+                delete: (id) => this.deleteScheduledTask(id),
+            },
             skills: {
-                upsert: (req) => this.upsertSkill(req),
+                upsert: (req) => this.saveSkill(req),
             },
             tools: {
-                upsert: (req) => this.upsertTool(req),
+                upsert: (req) => this.createTool(req),
             },
         };
         this.sessions = {
             create: (req) => this.createSession(req),
+            get: (id) => this.getSession(id),
             messages: (id) => this.listMessages(id),
+            timeline: (id) => this.getSessionTimeline(id),
+            delete: (id) => this.deleteSession(id),
+        };
+        this.skills = {
+            list: () => this.listSkills(),
+            get: (id) => this.getSkill(id),
+            create: (req) => this.createSkill(req),
+            update: (id, req) => this.updateSkill(id, req),
+            save: (req) => this.saveSkill(req),
+            import: (req) => this.importSkill(req),
+            delete: (id) => this.deleteSkill(id),
+            files: {
+                list: (id) => this.listSkillFiles(id),
+                get: (id, path) => this.getSkillFile(id, path),
+                set: (id, path, req) => this.setSkillFile(id, path, req),
+                delete: (id, path) => this.deleteSkillFile(id, path),
+            },
+        };
+        this.tools = {
+            list: () => this.listTools(),
+            get: (id) => this.getTool(id),
+            create: (req) => this.createTool(req),
+            delete: (id) => this.deleteTool(id),
+            skills: {
+                list: (skillId) => this.listSkillTools(skillId),
+                attach: (skillId, toolId) => this.attachToolToSkill(skillId, toolId),
+                detach: (skillId, toolId) => this.detachToolFromSkill(skillId, toolId),
+            },
+            secrets: {
+                list: (skillId) => this.listSkillSecrets(skillId),
+                set: (skillId, req) => this.setSkillSecret(skillId, req),
+                delete: (skillId, key) => this.deleteSkillSecret(skillId, key),
+            },
+        };
+        this.eval = {
+            tests: {
+                list: (skillId) => this.listEvalTests(skillId),
+                create: (skillId, req) => this.createEvalTest(skillId, req),
+                delete: (skillId, testId) => this.deleteEvalTest(skillId, testId),
+            },
+            run: (req) => this.runEval(req),
+            runs: {
+                get: (runId) => this.getEvalRun(runId),
+            },
+            stats: (req) => this.getEvalStats(req),
+            failures: (req) => this.listEvalFailures(req),
+            compare: (req) => this.compareEvalVersions(req),
         };
         this.events = {
             list: (req) => this.listEvents(req),
         };
     }
-    // --- Chat (core) ---
     async chat(req) {
-        const body = await this.request("POST", "/api/v1/chat", {
+        const body = await this.requestApi("POST", "/api/v1/chat", compactObject({
             skill_id: req.skillId,
             message: req.message,
             session_id: req.sessionId,
             metadata: req.metadata,
-        });
+        }));
         return {
             response: body.data.response,
             usage: {
@@ -58,97 +126,302 @@ export class BaoBoxClient {
             meta: body.meta,
         };
     }
-    // --- Sessions ---
-    async createSession(req) {
-        const body = await this.request("POST", "/api/v1/sessions", { skill_id: req.skillId });
+    async getHealth() {
+        const body = await this.requestNoAuth("GET", "/api/v1/health");
         return {
-            id: body.data.id,
-            skillId: body.data.skill_id,
-            tenantId: body.data.tenant_id,
-            createdAt: body.data.created_at,
-            updatedAt: body.data.updated_at,
+            status: body.data.status,
+            version: body.data.version,
+            meta: body.meta,
         };
     }
+    async createSession(req = {}) {
+        const body = await this.requestAdmin("POST", "/api/v1/sessions", compactObject({ skill_id: req.skillId }));
+        return mapSession(body.data);
+    }
+    async getSession(sessionId) {
+        const body = await this.requestAdmin("GET", `/api/v1/sessions/${encodeURIComponent(sessionId)}`);
+        return mapSession(body.data);
+    }
     async listMessages(sessionId) {
-        const body = await this.request("GET", `/api/v1/sessions/${encodeURIComponent(sessionId)}/messages`);
-        return body.data.map((m) => ({
-            id: m.id,
-            sessionId: m.session_id,
-            role: m.role,
-            content: m.content,
-            tokenCount: m.token_count,
-            createdAt: m.created_at,
-        }));
+        const body = await this.requestAdmin("GET", `/api/v1/sessions/${encodeURIComponent(sessionId)}/messages`);
+        return body.data.map(mapSessionMessage);
     }
-    // --- Admin: skills ---
-    async upsertSkill(req) {
-        const body = await this.request("POST", "/api/v1/admin/skills", {
-            id: req.id,
-            name: req.name,
-            description: req.description,
-            system_prompt: req.systemPrompt,
-            model: req.model,
-            temperature: req.temperature,
-            max_tokens: req.maxTokens,
-            tools: req.tools,
-        });
+    async getSessionTimeline(sessionId) {
+        const body = await this.requestAdmin("GET", `/api/v1/sessions/${encodeURIComponent(sessionId)}/timeline`);
         return {
-            id: body.data.id,
-            name: body.data.name,
-            description: body.data.description,
-            systemPrompt: body.data.system_prompt,
-            model: body.data.model,
-            temperature: body.data.temperature,
-            maxTokens: body.data.max_tokens,
-            tenantId: body.data.tenant_id,
-            createdAt: body.data.created_at,
-            updatedAt: body.data.updated_at,
+            sessionId: body.data.session_id,
+            events: body.data.events.map(mapEvent),
         };
     }
-    // --- Admin: tools ---
-    async upsertTool(req) {
-        const body = await this.request("POST", "/api/v1/admin/tools", {
+    async deleteSession(sessionId) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/sessions/${encodeURIComponent(sessionId)}`);
+        return body.data;
+    }
+    async listSkills() {
+        const body = await this.requestAdmin("GET", "/api/v1/skills");
+        return body.data.map(mapSkill);
+    }
+    async getSkill(skillId) {
+        const body = await this.requestAdmin("GET", `/api/v1/skills/${encodeURIComponent(skillId)}`);
+        return mapSkillWithFiles(body.data);
+    }
+    async createSkill(req) {
+        const body = await this.requestAdmin("POST", "/api/v1/skills", buildSkillWriteBody(req));
+        const skill = mapSkill(body.data);
+        if (req.tools)
+            await this.syncSkillTools(skill.id, req.tools);
+        return skill;
+    }
+    async updateSkill(skillId, req) {
+        const writeBody = buildSkillWriteBody(req);
+        const hasFieldUpdates = Object.keys(writeBody).length > 0;
+        const skill = hasFieldUpdates
+            ? mapSkill((await this.requestAdmin("PUT", `/api/v1/skills/${encodeURIComponent(skillId)}`, writeBody)).data)
+            : skillWithoutFiles(await this.getSkill(skillId));
+        if (req.tools)
+            await this.syncSkillTools(skillId, req.tools);
+        return skill;
+    }
+    async saveSkill(req) {
+        return req.id ? this.updateSkill(req.id, req) : this.createSkill(req);
+    }
+    async importSkill(req) {
+        const body = await this.requestAdmin("POST", "/api/v1/skills/import", {
+            url: req.url,
+            name: req.name,
+        });
+        return mapSkill(body.data);
+    }
+    async deleteSkill(skillId) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/skills/${encodeURIComponent(skillId)}`);
+        return body.data;
+    }
+    async listSkillFiles(skillId) {
+        const body = await this.requestAdmin("GET", `/api/v1/skills/${encodeURIComponent(skillId)}/files`);
+        return body.data.map(mapSkillFileSummary);
+    }
+    async getSkillFile(skillId, path) {
+        const body = await this.requestAdmin("GET", `/api/v1/skills/${encodeURIComponent(skillId)}/files/${encodePath(path)}`);
+        return mapSkillFile(body.data);
+    }
+    async setSkillFile(skillId, path, req) {
+        const body = await this.requestAdmin("PUT", `/api/v1/skills/${encodeURIComponent(skillId)}/files/${encodePath(path)}`, { content: req.content });
+        return body.data;
+    }
+    async deleteSkillFile(skillId, path) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/skills/${encodeURIComponent(skillId)}/files/${encodePath(path)}`);
+        return body.data;
+    }
+    async listTools() {
+        const body = await this.requestAdmin("GET", "/api/v1/tools");
+        return body.data.map(mapTool);
+    }
+    async getTool(toolId) {
+        const body = await this.requestAdmin("GET", `/api/v1/tools/${encodeURIComponent(toolId)}`);
+        return mapTool(body.data);
+    }
+    async createTool(req) {
+        const body = await this.requestAdmin("POST", "/api/v1/tools", {
             name: req.name,
             description: req.description,
             input_schema: req.inputSchema,
             handler_type: req.handlerType,
             handler_config: req.handlerConfig,
         });
+        return mapTool(body.data);
+    }
+    async deleteTool(toolId) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/tools/${encodeURIComponent(toolId)}`);
+        return body.data;
+    }
+    async listSkillTools(skillId) {
+        const body = await this.requestAdmin("GET", `/api/v1/tools/skills/${encodeURIComponent(skillId)}/tools`);
+        return body.data.map(mapTool);
+    }
+    async attachToolToSkill(skillId, toolId) {
+        const body = await this.requestAdmin("POST", `/api/v1/tools/skills/${encodeURIComponent(skillId)}/tools/${encodeURIComponent(toolId)}`);
+        return body.data;
+    }
+    async detachToolFromSkill(skillId, toolId) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/tools/skills/${encodeURIComponent(skillId)}/tools/${encodeURIComponent(toolId)}`);
+        return body.data;
+    }
+    async listSkillSecrets(skillId) {
+        const body = await this.requestAdmin("GET", `/api/v1/tools/skills/${encodeURIComponent(skillId)}/secrets`);
+        return body.data.map(mapSkillSecretSummary);
+    }
+    async setSkillSecret(skillId, req) {
+        const body = await this.requestAdmin("PUT", `/api/v1/tools/skills/${encodeURIComponent(skillId)}/secrets`, { key: req.key, value: req.value });
+        return body.data;
+    }
+    async deleteSkillSecret(skillId, key) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/tools/skills/${encodeURIComponent(skillId)}/secrets/${encodeURIComponent(key)}`);
+        return body.data;
+    }
+    async listApiKeys() {
+        const body = await this.requestAdmin("GET", "/api/v1/admin/keys");
+        return body.data.map(mapApiKey);
+    }
+    async createApiKey(req) {
+        const body = await this.requestAdmin("POST", "/api/v1/admin/keys", compactObject({
+            name: req.name,
+            permissions: req.permissions,
+            rate_limit: req.rateLimit,
+            expires_at: req.expiresAt,
+        }));
         return {
             id: body.data.id,
+            key: body.data.key,
             name: body.data.name,
-            description: body.data.description,
-            inputSchema: body.data.input_schema,
-            handlerType: body.data.handler_type,
-            handlerConfig: body.data.handler_config,
-            createdAt: body.data.created_at,
+            tenantId: body.data.tenant_id,
         };
     }
-    // --- Events ---
-    async listEvents(req) {
-        const qs = new URLSearchParams({ session_id: req.sessionId });
-        if (req.limit !== undefined)
-            qs.set("limit", String(req.limit));
-        if (req.after !== undefined)
-            qs.set("after", req.after);
-        const body = await this.request("GET", `/api/v1/events?${qs.toString()}`);
-        return body.data.map((e) => ({
-            id: e.id,
-            sessionId: e.session_id,
-            requestId: e.request_id,
-            eventType: e.event_type,
-            content: e.content,
-            metadata: safeParseJson(e.metadata),
-            tokenCount: e.token_count,
-            latencyMs: e.latency_ms,
-            parentEventId: e.parent_event_id,
-            createdAt: e.created_at,
+    async deleteApiKey(id) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/admin/keys/${encodeURIComponent(id)}`);
+        return body.data;
+    }
+    async getAdminStats(req) {
+        const body = await this.requestAdmin("GET", appendQuery("/api/v1/admin/stats", { since: req?.since }));
+        return body.data;
+    }
+    async listAdminLogs(req) {
+        const body = await this.requestAdmin("GET", appendQuery("/api/v1/admin/logs", {
+            limit: req?.limit !== undefined ? String(req.limit) : undefined,
+        }));
+        return body.data;
+    }
+    async listScheduledTasks() {
+        const body = await this.requestAdmin("GET", "/api/v1/admin/tasks");
+        return body.data.map(mapScheduledTask);
+    }
+    async createScheduledTask(req) {
+        const body = await this.requestAdmin("POST", "/api/v1/admin/tasks", compactObject({
+            name: req.name,
+            skill_id: req.skillId,
+            prompt: req.prompt,
+            telegram_chat_id: req.telegramChatId,
+            schedule: req.schedule,
+        }));
+        return body.data ? mapScheduledTask(body.data) : null;
+    }
+    async updateScheduledTask(id, req) {
+        const body = await this.requestAdmin("PATCH", `/api/v1/admin/tasks/${encodeURIComponent(id)}`, compactObject({
+            enabled: req.enabled,
+            schedule: req.schedule,
+            prompt: req.prompt,
+        }));
+        return body.data ? mapScheduledTask(body.data) : null;
+    }
+    async deleteScheduledTask(id) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/admin/tasks/${encodeURIComponent(id)}`);
+        return body.data;
+    }
+    async listEvalTests(skillId) {
+        const body = await this.requestAdmin("GET", `/api/v1/eval/skills/${encodeURIComponent(skillId)}/tests`);
+        return body.data.map(mapEvalCase);
+    }
+    async createEvalTest(skillId, req) {
+        const body = await this.requestAdmin("POST", `/api/v1/eval/skills/${encodeURIComponent(skillId)}/tests`, compactObject({
+            name: req.name,
+            input: req.input,
+            expected_behavior: req.expectedBehavior,
+            dimensions: req.dimensions,
+            passing_threshold: req.passingThreshold,
+        }));
+        return mapEvalCase(body.data);
+    }
+    async deleteEvalTest(skillId, testId) {
+        const body = await this.requestAdmin("DELETE", `/api/v1/eval/skills/${encodeURIComponent(skillId)}/tests/${encodeURIComponent(testId)}`);
+        return body.data;
+    }
+    async runEval(req) {
+        const body = await this.requestAdmin("POST", "/api/v1/eval/run", compactObject({
+            skill_id: req.skillId,
+            test_case_ids: req.testCaseIds,
+            prompt_version: req.promptVersion,
+        }));
+        return mapEvalRunExecution(body.data);
+    }
+    async getEvalRun(runId) {
+        const body = await this.requestAdmin("GET", `/api/v1/eval/runs/${encodeURIComponent(runId)}`);
+        return {
+            ...mapEvalRun(body.data),
+            results: body.data.results.map(mapEvalRunResult),
+        };
+    }
+    async getEvalStats(req) {
+        const body = await this.requestAdmin("GET", appendQuery("/api/v1/eval/stats", {
+            skill_id: req?.skillId,
+            since: req?.since,
+        }));
+        return {
+            skillId: body.data.skill_id,
+            period: body.data.period,
+            summary: body.data.summary
+                ? {
+                    total: body.data.summary.total,
+                    avgScore: body.data.summary.avg_score,
+                    distribution: body.data.summary.distribution,
+                }
+                : null,
+            trend: body.data.trend,
+        };
+    }
+    async listEvalFailures(req) {
+        const body = await this.requestAdmin("GET", appendQuery("/api/v1/eval/failures", {
+            skill_id: req?.skillId,
+            threshold: req?.threshold !== undefined ? String(req.threshold) : undefined,
+            limit: req?.limit !== undefined ? String(req.limit) : undefined,
         }));
+        return body.data;
+    }
+    async compareEvalVersions(req) {
+        const body = await this.requestAdmin("GET", appendQuery("/api/v1/eval/compare", {
+            skill_id: req.skillId,
+            a: req.a,
+            b: req.b,
+        }));
+        return {
+            skillId: body.data.skill_id,
+            versionA: body.data.version_a,
+            versionB: body.data.version_b,
+        };
+    }
+    async listEvents(req) {
+        const timeline = await this.getSessionTimeline(req.sessionId);
+        return timeline.events;
+    }
+    async syncSkillTools(skillId, desiredToolIds) {
+        const desired = new Set(desiredToolIds);
+        const current = await this.listSkillTools(skillId);
+        const currentIds = new Set(current.map((tool) => tool.id));
+        for (const toolId of currentIds) {
+            if (!desired.has(toolId)) {
+                await this.detachToolFromSkill(skillId, toolId);
+            }
+        }
+        for (const toolId of desired) {
+            if (!currentIds.has(toolId)) {
+                await this.attachToolToSkill(skillId, toolId);
+            }
+        }
+    }
+    async requestNoAuth(method, path, body) {
+        return this.request(method, path, "none", body);
     }
-    // --- core request plumbing ---
-    async request(method, path, body) {
+    async requestApi(method, path, body) {
+        return this.request(method, path, "apiKey", body);
+    }
+    async requestAdmin(method, path, body) {
+        return this.request(method, path, "adminSecret", body);
+    }
+    async request(method, path, authMode, body) {
         const url = `${this.endpoint}${path}`;
         const controller = new AbortController();
+        const headers = {
+            ...this.getAuthHeaders(authMode),
+            ...(body !== undefined ? { "content-type": "application/json" } : {}),
+        };
         const timer = this.timeoutMs > 0
             ? setTimeout(() => controller.abort(), this.timeoutMs)
             : null;
@@ -156,10 +429,7 @@ export class BaoBoxClient {
         try {
             res = await this.fetch(url, {
                 method,
-                headers: {
-                    authorization: `Bearer ${this.apiKey}`,
-                    ...(body !== undefined ? { "content-type": "application/json" } : {}),
-                },
+                headers,
                 body: body !== undefined ? JSON.stringify(body) : undefined,
                 signal: controller.signal,
             });
@@ -177,27 +447,271 @@ export class BaoBoxClient {
         const text = await res.text();
         const parsed = text.length ? safeParseJson(text) : {};
         if (!res.ok) {
-            const errObj = parsed.error;
+            const errObj = parsed
+                .error;
             throw new BaoBoxError(res.status, errObj?.code ?? "HTTP_ERROR", errObj?.message ?? res.statusText, errObj?.request_id ?? null, parsed);
         }
         const envelope = parsed;
         return {
             data: envelope.data,
-            meta: envelope.metadata
-                ? {
-                    requestId: envelope.metadata.request_id,
-                    latencyMs: envelope.metadata.latency_ms,
-                    model: envelope.metadata.model,
-                    trace: envelope.metadata.trace?.map((t) => ({
-                        toolName: t.tool_name,
-                        input: t.input,
-                        output: t.output,
-                        latencyMs: t.latency_ms,
-                    })),
-                }
-                : { requestId: "", latencyMs: 0 },
+            meta: mapResponseMeta(envelope.metadata),
         };
     }
+    getAuthHeaders(authMode) {
+        if (authMode === "none")
+            return {};
+        if (authMode === "apiKey") {
+            if (!this.apiKey) {
+                throw new Error("BaoBoxClient: apiKey required for chat methods");
+            }
+            return { authorization: `Bearer ${this.apiKey}` };
+        }
+        if (!this.adminSecret) {
+            throw new Error("BaoBoxClient: adminSecret required for admin methods");
+        }
+        return { authorization: `Bearer ${this.adminSecret}` };
+    }
+}
+function mapResponseMeta(metadata) {
+    if (!metadata)
+        return { requestId: "", latencyMs: 0 };
+    return {
+        requestId: metadata.request_id,
+        latencyMs: metadata.latency_ms,
+        model: metadata.model,
+        trace: metadata.trace?.map((trace) => ({
+            toolName: trace.tool_name,
+            input: trace.input,
+            output: trace.output,
+            latencyMs: trace.latency_ms,
+        })),
+    };
+}
+function mapSession(raw) {
+    return {
+        id: raw.id,
+        skillId: raw.skill_id,
+        tenantId: raw.tenant_id,
+        createdAt: raw.created_at,
+        updatedAt: raw.updated_at,
+    };
+}
+function mapSessionMessage(raw) {
+    return {
+        id: raw.id,
+        sessionId: raw.session_id,
+        role: raw.role,
+        content: raw.content,
+        tokenCount: raw.token_count,
+        createdAt: raw.created_at,
+    };
+}
+function mapEvent(raw) {
+    return {
+        id: raw.id,
+        sessionId: raw.session_id,
+        requestId: raw.request_id,
+        eventType: raw.event_type,
+        content: raw.content,
+        metadata: toJsonObject(raw.metadata),
+        tokenCount: raw.token_count,
+        latencyMs: raw.latency_ms,
+        parentEventId: raw.parent_event_id,
+        createdAt: raw.created_at,
+    };
+}
+function mapSkill(raw) {
+    return {
+        id: raw.id,
+        name: raw.name,
+        description: raw.description,
+        systemPrompt: raw.system_prompt,
+        model: raw.model,
+        temperature: raw.temperature,
+        maxTokens: raw.max_tokens,
+        sourceUrl: raw.source_url,
+        tenantId: raw.tenant_id,
+        createdAt: raw.created_at,
+        updatedAt: raw.updated_at,
+    };
+}
+function mapSkillWithFiles(raw) {
+    return {
+        ...mapSkill(raw),
+        files: raw.files.map((file) => ({
+            path: file.path,
+            size: file.size,
+        })),
+    };
+}
+function skillWithoutFiles(skill) {
+    const { files: _files, ...rest } = skill;
+    return rest;
+}
+function mapSkillFileSummary(raw) {
+    return {
+        path: raw.path,
+        size: raw.size,
+        updatedAt: raw.updated_at,
+    };
+}
+function mapSkillFile(raw) {
+    return {
+        id: raw.id,
+        skillId: raw.skill_id,
+        path: raw.path,
+        content: raw.content,
+        createdAt: raw.created_at,
+        updatedAt: raw.updated_at,
+    };
+}
+function mapTool(raw) {
+    return {
+        id: raw.id,
+        name: raw.name,
+        description: raw.description,
+        inputSchema: raw.input_schema,
+        handlerType: raw.handler_type,
+        handlerConfig: raw.handler_config,
+        createdAt: raw.created_at,
+    };
+}
+function mapSkillSecretSummary(raw) {
+    return {
+        id: raw.id,
+        key: raw.key,
+        createdAt: raw.created_at,
+    };
+}
+function mapApiKey(raw) {
+    return {
+        apiKeyId: raw.apiKeyId,
+        name: raw.name,
+        permissions: raw.permissions,
+        rateLimit: raw.rateLimit,
+        tenantId: raw.tenantId,
+        createdAt: raw.createdAt,
+        expiresAt: raw.expiresAt,
+    };
+}
+function mapScheduledTask(raw) {
+    return {
+        id: raw.id,
+        name: raw.name,
+        skillId: raw.skill_id,
+        prompt: raw.prompt,
+        telegramChatId: raw.telegram_chat_id,
+        schedule: raw.schedule,
+        enabled: raw.enabled,
+        createdAt: raw.created_at,
+        lastRunAt: raw.last_run_at,
+    };
+}
+function mapEvalCase(raw) {
+    return {
+        id: raw.id,
+        skillId: raw.skill_id,
+        name: raw.name,
+        input: raw.input,
+        expectedBehavior: raw.expected_behavior,
+        dimensions: raw.dimensions,
+        passingThreshold: raw.passing_threshold,
+        createdAt: raw.created_at,
+        updatedAt: raw.updated_at,
+    };
+}
+function mapEvalRunExecution(raw) {
+    return {
+        runId: raw.run_id,
+        status: raw.status,
+        totalCases: raw.total_cases,
+        passed: raw.passed,
+        failed: raw.failed,
+        avgScore: raw.avg_score,
+        results: raw.results.map(mapEvalRunResultSummary),
+        durationMs: raw.duration_ms,
+    };
+}
+function mapEvalRunResultSummary(raw) {
+    return {
+        testCaseId: raw.test_case_id,
+        status: raw.status,
+        score: raw.score,
+        scores: raw.scores,
+        response: raw.response,
+        reasoning: raw.reasoning,
+    };
+}
+function mapEvalRun(raw) {
+    return {
+        id: raw.id,
+        skillId: raw.skill_id,
+        promptVersion: raw.prompt_version,
+        status: raw.status,
+        totalCases: raw.total_cases,
+        passed: raw.passed,
+        failed: raw.failed,
+        avgScore: raw.avg_score,
+        metadata: raw.metadata,
+        createdAt: raw.created_at,
+        completedAt: raw.completed_at,
+    };
+}
+function mapEvalRunResult(raw) {
+    return {
+        id: raw.id,
+        runId: raw.run_id,
+        testCaseId: raw.test_case_id,
+        sessionId: raw.session_id,
+        status: raw.status,
+        score: raw.score,
+        scoresJson: raw.scores_json,
+        response: raw.response,
+        reasoning: raw.reasoning,
+        latencyMs: raw.latency_ms,
+        createdAt: raw.created_at,
+    };
+}
+function buildSkillWriteBody(req) {
+    return compactObject({
+        name: req.name,
+        description: req.description,
+        system_prompt: req.systemPrompt,
+        model: req.model,
+        temperature: req.temperature,
+        max_tokens: req.maxTokens,
+        source_url: req.sourceUrl,
+        files: req.files,
+    });
+}
+function appendQuery(path, query) {
+    const qs = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value !== undefined)
+            qs.set(key, value);
+    }
+    const suffix = qs.toString();
+    return suffix ? `${path}?${suffix}` : path;
+}
+function encodePath(path) {
+    return path
+        .split("/")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => encodeURIComponent(segment))
+        .join("/");
+}
+function compactObject(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== undefined));
+}
+function toJsonObject(input) {
+    if (typeof input === "string") {
+        const parsed = safeParseJson(input);
+        return isJsonObject(parsed) ? parsed : {};
+    }
+    return isJsonObject(input) ? input : {};
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function safeParseJson(text) {
     try {