@openagentpack/playground 0.0.2-beta.0 → 0.1.0

package/dist/bin/playground.js

@@ -875,6 +875,10 @@ var qoder_default = [
           {
             name: "image_gen",
             enabled: true
+          },
+          {
+            name: "deliver_artifacts",
+            enabled: true
           }
         ],
         defaultConfig: {
@@ -883,13 +887,7 @@ var qoder_default = [
         type: "builtin_toolkit"
       }
     ],
-    skills: [
-      {
-        type: "official",
-        id: "skill_N2U0MDAwYWM2NDQ0NGFkNjljMz",
-        version: "1.0"
-      }
-    ],
+    skills: [],
     mcpServers: []
   }
 ];
@@ -2194,7 +2192,7 @@ async function writeProviderConfig(input) {
 // ../../apps/server/src/schemas/config.ts
 import { z as z3 } from "@hono/zod-openapi";
 var AgentsConfigSchema = z3.object({
-  AGENTS_PROVIDER: z3.enum(AGENTS_CONFIG_PROVIDERS2).optional()
+  AGENTS_PROVIDER: z3.enum(AGENTS_CONFIG_PROVIDERS2)
 }).catchall(z3.string()).openapi("AgentsConfig");
 var AgentsConfigSnapshotSchema = z3.object({
   AGENTS_PROVIDER: z3.enum(AGENTS_CONFIG_PROVIDERS2).optional()
@@ -2359,7 +2357,45 @@ environmentsRoute.openapi(deleteEnvironmentRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/files.ts
-import { OpenAPIHono as OpenAPIHono4 } from "@hono/zod-openapi";
+import { createRoute as createRoute4, OpenAPIHono as OpenAPIHono4 } from "@hono/zod-openapi";
+
+// ../../apps/server/src/schemas/files.ts
+import { z as z5 } from "@hono/zod-openapi";
+var ProviderFileInfoSchema = z5.object({
+  id: z5.string(),
+  filename: z5.string(),
+  mime_type: z5.string(),
+  size_bytes: z5.number(),
+  created_at: z5.string(),
+  downloadable: z5.boolean().optional(),
+  status: z5.string().optional(),
+  purpose: z5.string().optional(),
+  available: z5.boolean().optional()
+}).openapi("ProviderFileInfo");
+var UploadFileFormSchema = z5.object({
+  file: z5.instanceof(File).openapi({ type: "string", format: "binary" })
+});
+var FilesResponseSchema = z5.object({
+  files: z5.array(ProviderFileInfoSchema)
+});
+var FileStatusesBodySchema = z5.object({
+  fileIds: z5.array(z5.string())
+});
+var FileStatusInfoSchema = z5.object({
+  id: z5.string(),
+  status: z5.string().optional(),
+  available: z5.boolean().optional()
+});
+var FileStatusesResponseSchema = z5.object({
+  files: z5.array(FileStatusInfoSchema)
+});
+var FileParamsSchema = z5.object({
+  id: z5.string().min(1)
+});
+var FileDownloadResponseSchema = z5.object({
+  url: z5.string(),
+  expires_at: z5.string().optional()
+});
 
 // ../../apps/server/src/services/files/upload.ts
 import {
@@ -2413,21 +2449,38 @@ async function getUserFileStatuses(fileIds) {
 // ../../apps/server/src/routes/files.ts
 var filesRoute = new OpenAPIHono4();
 var MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
-filesRoute.post("/files", async (c) => {
-  let body;
-  try {
-    body = await c.req.parseBody();
-  } catch (error) {
-    return jsonError(error, 400);
-  }
-  const file = body.file;
-  if (!(file instanceof File) || file.size === 0) {
-    return c.json({ error: { message: "file is required" } }, 400);
-  }
-  if (file.size > MAX_UPLOAD_BYTES) {
-    return c.json({ error: { message: "file too large" } }, 413);
+var uploadFileRoute = createRoute4({
+  method: "post",
+  path: "/files",
+  operationId: "uploadFile",
+  request: {
+    body: {
+      required: true,
+      content: { "multipart/form-data": { schema: UploadFileFormSchema } }
+    }
+  },
+  responses: {
+    201: {
+      description: "Upload a workspace file",
+      content: { "application/json": { schema: ProviderFileInfoSchema } }
+    },
+    413: {
+      description: "File exceeds the upload size limit",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    ...errorResponses
   }
-  try {
+});
+filesRoute.openapi(
+  uploadFileRoute,
+  async (c) => {
+    const { file } = c.req.valid("form");
+    if (file.size === 0) {
+      return c.json({ error: { message: "file is required" } }, 400);
+    }
+    if (file.size > MAX_UPLOAD_BYTES) {
+      return c.json({ error: { message: "file too large" } }, 413);
+    }
     const content = new Uint8Array(await file.arrayBuffer());
     const info = await uploadUserFile({
       content,
@@ -2435,80 +2488,109 @@ filesRoute.post("/files", async (c) => {
       mimeType: file.type || void 0
     });
     return c.json(info, 201);
-  } catch (error) {
-    return jsonError(error);
+  },
+  (result, c) => {
+    if (!result.success) return c.json({ error: { message: "file is required" } }, 400);
   }
-});
-filesRoute.get("/files", async (c) => {
-  try {
-    const files = await listUserFiles();
-    return c.json({ files });
-  } catch (error) {
-    return jsonError(error);
+);
+var listFilesRoute = createRoute4({
+  method: "get",
+  path: "/files",
+  operationId: "listFiles",
+  responses: {
+    200: {
+      description: "List workspace files",
+      content: { "application/json": { schema: FilesResponseSchema } }
+    },
+    ...errorResponses
   }
 });
-filesRoute.post("/files/status", async (c) => {
-  let body;
-  try {
-    body = await c.req.json();
-  } catch (error) {
-    return jsonError(error, 400);
-  }
-  const fileIds = body.fileIds;
-  if (!Array.isArray(fileIds) || fileIds.some((id) => typeof id !== "string")) {
-    return c.json({ error: { message: "fileIds (string[]) is required" } }, 400);
-  }
-  try {
-    const files = await getUserFileStatuses(fileIds);
-    return c.json({ files });
-  } catch (error) {
-    return jsonError(error);
+filesRoute.openapi(listFilesRoute, async (c) => {
+  const files = await listUserFiles();
+  return c.json({ files }, 200);
+});
+var getFileStatusesRoute = createRoute4({
+  method: "post",
+  path: "/files/status",
+  operationId: "getFileStatuses",
+  request: {
+    body: {
+      required: true,
+      content: { "application/json": { schema: FileStatusesBodySchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Get file scan statuses",
+      content: { "application/json": { schema: FileStatusesResponseSchema } }
+    },
+    ...errorResponses
   }
 });
-filesRoute.get("/files/:id/download", async (c) => {
-  const id = c.req.param("id");
-  if (!id) {
-    return c.json({ error: { message: "file id is required" } }, 400);
+filesRoute.openapi(
+  getFileStatusesRoute,
+  async (c) => {
+    const { fileIds } = c.req.valid("json");
+    const files = await getUserFileStatuses(fileIds);
+    return c.json({ files }, 200);
+  },
+  (result, c) => {
+    if (!result.success) return c.json({ error: { message: "fileIds (string[]) is required" } }, 400);
   }
-  try {
-    const result = await getUserFileDownloadUrl(id);
-    return c.json(result);
-  } catch (error) {
-    return jsonError(error);
+);
+var downloadFileRoute = createRoute4({
+  method: "get",
+  path: "/files/{id}/download",
+  operationId: "downloadFile",
+  request: { params: FileParamsSchema },
+  responses: {
+    200: {
+      description: "Resolve a short-lived file download URL",
+      content: { "application/json": { schema: FileDownloadResponseSchema } }
+    },
+    ...errorResponses
   }
 });
-filesRoute.delete("/files/:id", async (c) => {
-  const id = c.req.param("id");
-  if (!id) {
-    return c.json({ error: { message: "file id is required" } }, 400);
-  }
-  try {
-    await deleteUserFile(id);
-    return c.body(null, 204);
-  } catch (error) {
-    return jsonError(error);
+filesRoute.openapi(downloadFileRoute, async (c) => {
+  const { id } = c.req.valid("param");
+  const result = await getUserFileDownloadUrl(id);
+  return c.json(result, 200);
+});
+var deleteFileRoute = createRoute4({
+  method: "delete",
+  path: "/files/{id}",
+  operationId: "deleteFile",
+  request: { params: FileParamsSchema },
+  responses: {
+    204: { description: "File deleted" },
+    ...errorResponses
   }
 });
+filesRoute.openapi(deleteFileRoute, async (c) => {
+  const { id } = c.req.valid("param");
+  await deleteUserFile(id);
+  return c.body(null, 204);
+});
 
 // ../../apps/server/src/routes/models.ts
-import { createRoute as createRoute4, OpenAPIHono as OpenAPIHono5 } from "@hono/zod-openapi";
+import { createRoute as createRoute5, OpenAPIHono as OpenAPIHono5 } from "@hono/zod-openapi";
 import { listProviderModelsForContext } from "@openagentpack/sdk";
 
 // ../../apps/server/src/schemas/models.ts
-import { z as z5 } from "@hono/zod-openapi";
-var ModelOptionSchema = z5.object({
-  id: z5.string(),
-  display_name: z5.string(),
-  is_enabled: z5.boolean().optional(),
-  is_new: z5.boolean().optional()
+import { z as z6 } from "@hono/zod-openapi";
+var ModelOptionSchema = z6.object({
+  id: z6.string(),
+  display_name: z6.string(),
+  is_enabled: z6.boolean().optional(),
+  is_new: z6.boolean().optional()
 });
-var ModelsResponseSchema = z5.object({
-  models: z5.array(ModelOptionSchema)
+var ModelsResponseSchema = z6.object({
+  models: z6.array(ModelOptionSchema)
 });
 
 // ../../apps/server/src/routes/models.ts
 var modelsRoute = new OpenAPIHono5();
-var listModelsRoute = createRoute4({
+var listModelsRoute = createRoute5({
   method: "get",
   path: "/models",
   responses: {
@@ -2536,73 +2618,73 @@ modelsRoute.openapi(listModelsRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/index.ts
-import { createRoute as createRoute9, OpenAPIHono as OpenAPIHono10 } from "@hono/zod-openapi";
+import { createRoute as createRoute10, OpenAPIHono as OpenAPIHono10 } from "@hono/zod-openapi";
 
 // ../../apps/server/src/schemas/sessions.ts
-import { z as z6 } from "@hono/zod-openapi";
+import { z as z7 } from "@hono/zod-openapi";
 import { SessionEventSchema, SessionSchema } from "@openagentpack/sdk";
-var SessionListResponseSchema = z6.object({
-  data: z6.array(SessionSchema),
-  next_page_token: z6.string().nullish()
+var SessionListResponseSchema = z7.object({
+  data: z7.array(SessionSchema),
+  next_page_token: z7.string().nullish()
 }).openapi("SessionListResponse");
-var SessionDetailResponseSchema = z6.object({
+var SessionDetailResponseSchema = z7.object({
   session: SessionSchema,
-  events: z6.array(SessionEventSchema),
-  events_next_page_token: z6.string().nullish()
+  events: z7.array(SessionEventSchema),
+  events_next_page_token: z7.string().nullish()
 }).openapi("SessionDetailResponse");
-var SessionEventsPageResponseSchema = z6.object({
-  events: z6.array(SessionEventSchema),
-  events_next_page_token: z6.string().nullish()
+var SessionEventsPageResponseSchema = z7.object({
+  events: z7.array(SessionEventSchema),
+  events_next_page_token: z7.string().nullish()
 }).openapi("SessionEventsPageResponse");
-var SessionDeleteResponseSchema = z6.object({
-  session_id: z6.string(),
-  deleted: z6.boolean()
+var SessionDeleteResponseSchema = z7.object({
+  session_id: z7.string(),
+  deleted: z7.boolean()
 }).openapi("SessionDeleteResponse");
-var SessionsQuerySchema = z6.object({
+var SessionsQuerySchema = z7.object({
   // Non-numeric values resolve to `undefined` so the handler clamps to a
   // default instead of the request being rejected with a 400.
-  limit: z6.preprocess((value) => {
+  limit: z7.preprocess((value) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : void 0;
-  }, z6.number().int().optional()),
-  agentId: z6.string().optional(),
+  }, z7.number().int().optional()),
+  agentId: z7.string().optional(),
   // Opaque cursor for the next page (provider's next_page / next_page_token, passed through verbatim).
-  pageToken: z6.string().optional()
+  pageToken: z7.string().optional()
 });
-var SessionDetailQuerySchema = z6.object({
-  agentId: z6.string().optional()
+var SessionDetailQuerySchema = z7.object({
+  agentId: z7.string().optional()
 });
-var SessionEventsQuerySchema = z6.object({
-  agentId: z6.string().optional(),
-  pageToken: z6.string().optional(),
-  limit: z6.preprocess((value) => {
+var SessionEventsQuerySchema = z7.object({
+  agentId: z7.string().optional(),
+  pageToken: z7.string().optional(),
+  limit: z7.preprocess((value) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : void 0;
-  }, z6.number().int().optional())
+  }, z7.number().int().optional())
 });
-var SessionParamsSchema = z6.object({
-  sessionId: z6.string()
+var SessionParamsSchema = z7.object({
+  sessionId: z7.string()
 });
-var CreateSessionBodySchema = z6.object({
-  agentId: z6.string(),
-  prompt: z6.string().min(1),
+var CreateSessionBodySchema = z7.object({
+  agentId: z7.string(),
+  prompt: z7.string().min(1),
   // Required: a session must be pinned to a cloud environment (sandbox). Both transports
   // enforce this so Mode A (REST/OpenAPI) and Mode B (console) reject env-less creates.
-  environmentId: z6.string().min(1),
+  environmentId: z7.string().min(1),
   // Optional: cloud vault ids to bind a user-supplied credential so the sandbox receives it.
   // Top-level binding shape matches the console createSession.
-  vaultIds: z6.array(z6.string()).optional(),
-  title: z6.string().optional(),
+  vaultIds: z7.array(z7.string()).optional(),
+  title: z7.string().optional(),
   // Uploaded files to mount as session resources so the task can read the user's files.
   // Each file needs a mount_path (provider rejects a file resource without one).
-  files: z6.array(z6.object({ fileId: z6.string(), mountPath: z6.string() })).optional(),
+  files: z7.array(z7.object({ fileId: z7.string(), mountPath: z7.string() })).optional(),
   // Model the agent should run for this session. If present, createSession applies it
   // to the agent config immediately before starting the run.
-  model: z6.string().optional()
+  model: z7.string().optional()
 });
-var SendMessageBodySchema = z6.object({
-  agentId: z6.string().optional(),
-  message: z6.string().min(1)
+var SendMessageBodySchema = z7.object({
+  agentId: z7.string().optional(),
+  message: z7.string().min(1)
 });
 
 // ../../apps/server/src/services/sessions/event-sanitizer.ts
@@ -2613,9 +2695,9 @@ function shouldIncludeDebugRaw(request) {
 }
 
 // ../../apps/server/src/routes/sessions/detail.ts
-import { createRoute as createRoute5, OpenAPIHono as OpenAPIHono6 } from "@hono/zod-openapi";
+import { createRoute as createRoute6, OpenAPIHono as OpenAPIHono6 } from "@hono/zod-openapi";
 var sessionsDetailRoute = new OpenAPIHono6();
-var getSessionRoute = createRoute5({
+var getSessionRoute = createRoute6({
   method: "get",
   path: "/sessions/{sessionId}",
   request: {
@@ -2644,7 +2726,7 @@ sessionsDetailRoute.openapi(getSessionRoute, async (c) => {
     200
   );
 });
-var deleteSessionRoute = createRoute5({
+var deleteSessionRoute = createRoute6({
   method: "delete",
   path: "/sessions/{sessionId}",
   request: {
@@ -2667,9 +2749,9 @@ sessionsDetailRoute.openapi(deleteSessionRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/events.ts
-import { createRoute as createRoute6, OpenAPIHono as OpenAPIHono7 } from "@hono/zod-openapi";
+import { createRoute as createRoute7, OpenAPIHono as OpenAPIHono7 } from "@hono/zod-openapi";
 var sessionsEventsRoute = new OpenAPIHono7();
-var listSessionEventsRoute = createRoute6({
+var listSessionEventsRoute = createRoute7({
   method: "get",
   path: "/sessions/{sessionId}/events",
   request: {
@@ -2706,9 +2788,9 @@ sessionsEventsRoute.openapi(listSessionEventsRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/messages.ts
-import { createRoute as createRoute7, OpenAPIHono as OpenAPIHono8 } from "@hono/zod-openapi";
+import { createRoute as createRoute8, OpenAPIHono as OpenAPIHono8 } from "@hono/zod-openapi";
 var sessionsMessagesRoute = new OpenAPIHono8();
-var sendMessageRoute = createRoute7({
+var sendMessageRoute = createRoute8({
   method: "post",
   path: "/sessions/{sessionId}/messages",
   request: {
@@ -2737,15 +2819,15 @@ sessionsMessagesRoute.openapi(sendMessageRoute, async (c) => {
 });
 
 // ../../apps/server/src/routes/sessions/stream.ts
-import { createRoute as createRoute8, OpenAPIHono as OpenAPIHono9, z as z7 } from "@hono/zod-openapi";
+import { createRoute as createRoute9, OpenAPIHono as OpenAPIHono9, z as z8 } from "@hono/zod-openapi";
 var sessionsStreamRoute = new OpenAPIHono9();
-var SessionStreamQuerySchema = z7.object({
-  after: z7.preprocess((value) => {
+var SessionStreamQuerySchema = z8.object({
+  after: z8.preprocess((value) => {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : void 0;
-  }, z7.number().int().optional())
+  }, z8.number().int().optional())
 });
-var streamSessionRoute = createRoute8({
+var streamSessionRoute = createRoute9({
   method: "get",
   path: "/sessions/{sessionId}/stream",
   request: {
@@ -2757,7 +2839,7 @@ var streamSessionRoute = createRoute8({
       description: "Stream session events as Server-Sent Events",
       content: {
         "text/event-stream": {
-          schema: z7.string().openapi({
+          schema: z8.string().openapi({
             description: 'SSE frames with event types "event", "done", and "ping".'
           })
         }
@@ -2868,7 +2950,7 @@ data: ${data}
 
 // ../../apps/server/src/routes/sessions/index.ts
 var sessionsRoute = new OpenAPIHono10();
-var listSessionsRoute = createRoute9({
+var listSessionsRoute = createRoute10({
   method: "get",
   path: "/sessions",
   request: {
@@ -2894,7 +2976,7 @@ sessionsRoute.openapi(listSessionsRoute, async (c) => {
   });
   return c.json({ data: sessions, next_page_token: nextPageToken ?? null }, 200);
 });
-var createSessionRoute = createRoute9({
+var createSessionRoute = createRoute10({
   method: "post",
   path: "/sessions",
   request: {
@@ -2936,7 +3018,52 @@ sessionsRoute.route("/", sessionsMessagesRoute);
 sessionsRoute.route("/", sessionsStreamRoute);
 
 // ../../apps/server/src/routes/skills.ts
-import { OpenAPIHono as OpenAPIHono11 } from "@hono/zod-openapi";
+import { createRoute as createRoute11, OpenAPIHono as OpenAPIHono11 } from "@hono/zod-openapi";
+
+// ../../apps/server/src/schemas/skills.ts
+import { z as z9 } from "@hono/zod-openapi";
+var ProviderSkillInfoSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  description: z9.string().optional(),
+  source: z9.enum(["custom", "official"]),
+  status: z9.enum(["checking", "active", "rejected", "deleted"]),
+  latest_version: z9.string().optional(),
+  created_at: z9.string().optional(),
+  updated_at: z9.string().optional()
+}).openapi("ProviderSkillInfo");
+var UploadSkillFileFormSchema = z9.object({
+  file: z9.instanceof(File).openapi({ type: "string", format: "binary" })
+});
+var CreateSkillBodySchema = z9.object({
+  fileId: z9.string().min(1)
+});
+var WarmSkillBodySchema = z9.object({
+  name: z9.string().min(1),
+  url: z9.string().min(1)
+});
+var WarmSkillResponseSchema = z9.object({
+  ok: z9.literal(true)
+});
+var SkillsQuerySchema = z9.object({
+  source: z9.enum(["custom", "official"]).optional()
+});
+var SkillsResponseSchema = z9.object({
+  skills: z9.array(ProviderSkillInfoSchema)
+});
+var SkillStatusesBodySchema = z9.object({
+  skillIds: z9.array(z9.string())
+});
+var SkillStatusInfoSchema = z9.object({
+  id: z9.string(),
+  status: z9.enum(["checking", "active", "rejected", "deleted"]).optional()
+});
+var SkillStatusesResponseSchema = z9.object({
+  skills: z9.array(SkillStatusInfoSchema)
+});
+var SkillParamsSchema = z9.object({
+  id: z9.string().min(1)
+});
 
 // ../../apps/server/src/services/skills/manage.ts
 import {
@@ -3038,145 +3165,209 @@ async function warmSkillByUrl(name, url) {
 // ../../apps/server/src/routes/skills.ts
 var skillsRoute = new OpenAPIHono11();
 var MAX_UPLOAD_BYTES2 = 100 * 1024 * 1024;
-skillsRoute.post("/skills/upload-file", async (c) => {
-  let body;
-  try {
-    body = await c.req.parseBody();
-  } catch (error) {
-    return jsonError(error, 400);
-  }
-  const file = body.file;
-  if (!(file instanceof File) || file.size === 0) {
-    return c.json({ error: { message: "file is required" } }, 400);
-  }
-  if (!file.name.toLowerCase().endsWith(".zip")) {
-    return c.json({ error: { message: "skill file must be a .zip" } }, 400);
-  }
-  if (file.size > MAX_UPLOAD_BYTES2) {
-    return c.json({ error: { message: "file too large" } }, 413);
+var uploadSkillFileRoute = createRoute11({
+  method: "post",
+  path: "/skills/upload-file",
+  operationId: "uploadSkillFile",
+  request: {
+    body: {
+      required: true,
+      content: { "multipart/form-data": { schema: UploadSkillFileFormSchema } }
+    }
+  },
+  responses: {
+    201: {
+      description: "Upload a skill archive as a file pending audit",
+      content: { "application/json": { schema: ProviderFileInfoSchema } }
+    },
+    413: {
+      description: "Skill archive exceeds the upload size limit",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    ...errorResponses
   }
-  try {
+});
+skillsRoute.openapi(
+  uploadSkillFileRoute,
+  async (c) => {
+    const { file } = c.req.valid("form");
+    if (file.size === 0) return c.json({ error: { message: "file is required" } }, 400);
+    if (!file.name.toLowerCase().endsWith(".zip")) {
+      return c.json({ error: { message: "skill file must be a .zip" } }, 400);
+    }
+    if (file.size > MAX_UPLOAD_BYTES2) return c.json({ error: { message: "file too large" } }, 413);
     const content = new Uint8Array(await file.arrayBuffer());
     const info = await uploadUserSkillFile({ content, filename: file.name });
     return c.json(info, 201);
-  } catch (error) {
-    return jsonError(error);
-  }
-});
-skillsRoute.post("/skills", async (c) => {
-  let body;
-  try {
-    body = await c.req.json();
-  } catch (error) {
-    return jsonError(error, 400);
+  },
+  (result, c) => {
+    if (!result.success) return c.json({ error: { message: "file is required" } }, 400);
   }
-  const fileId = body.fileId;
-  if (typeof fileId !== "string" || fileId.length === 0) {
-    return c.json({ error: { message: "fileId is required" } }, 400);
+);
+var createSkillRoute = createRoute11({
+  method: "post",
+  path: "/skills",
+  operationId: "createSkill",
+  request: {
+    body: {
+      required: true,
+      content: { "application/json": { schema: CreateSkillBodySchema } }
+    }
+  },
+  responses: {
+    201: {
+      description: "Create a skill from an audited file",
+      content: { "application/json": { schema: ProviderSkillInfoSchema } }
+    },
+    ...errorResponses
   }
-  try {
+});
+skillsRoute.openapi(
+  createSkillRoute,
+  async (c) => {
+    const { fileId } = c.req.valid("json");
     const info = await createUserSkillFromFile(fileId);
     return c.json(info, 201);
-  } catch (error) {
-    return jsonError(error);
-  }
-});
-skillsRoute.post("/skills/warm", async (c) => {
-  let body;
-  try {
-    body = await c.req.json();
-  } catch (error) {
-    return jsonError(error, 400);
+  },
+  (result, c) => {
+    if (!result.success) return c.json({ error: { message: "fileId is required" } }, 400);
   }
-  const { name, url } = body;
-  if (typeof name !== "string" || !name || typeof url !== "string" || !url) {
-    return c.json({ error: { message: "name and url are required" } }, 400);
+);
+var warmSkillRoute = createRoute11({
+  method: "post",
+  path: "/skills/warm",
+  operationId: "warmSkill",
+  request: {
+    body: {
+      required: true,
+      content: { "application/json": { schema: WarmSkillBodySchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Warm a custom skill until it is active",
+      content: { "application/json": { schema: WarmSkillResponseSchema } }
+    },
+    ...errorResponses
   }
-  try {
+});
+skillsRoute.openapi(
+  warmSkillRoute,
+  async (c) => {
+    const { name, url } = c.req.valid("json");
     await warmSkillByUrl(name, url);
     return c.json({ ok: true }, 200);
-  } catch (error) {
-    return jsonError(error);
-  }
-});
-skillsRoute.get("/skills", async (c) => {
-  const source = c.req.query("source");
-  if (source !== void 0 && source !== "custom" && source !== "official") {
-    return c.json({ error: { message: "source must be 'custom' or 'official'" } }, 400);
+  },
+  (result, c) => {
+    if (!result.success) return c.json({ error: { message: "name and url are required" } }, 400);
   }
-  try {
-    const skills = await listUserSkills(source);
-    return c.json({ skills });
-  } catch (error) {
-    return jsonError(error);
+);
+var listSkillsRoute = createRoute11({
+  method: "get",
+  path: "/skills",
+  operationId: "listSkills",
+  request: { query: SkillsQuerySchema },
+  responses: {
+    200: {
+      description: "List custom or official skills",
+      content: { "application/json": { schema: SkillsResponseSchema } }
+    },
+    ...errorResponses
   }
 });
-skillsRoute.post("/skills/status", async (c) => {
-  let body;
-  try {
-    body = await c.req.json();
-  } catch (error) {
-    return jsonError(error, 400);
-  }
-  const skillIds = body.skillIds;
-  if (!Array.isArray(skillIds) || skillIds.some((id) => typeof id !== "string")) {
-    return c.json({ error: { message: "skillIds (string[]) is required" } }, 400);
+skillsRoute.openapi(
+  listSkillsRoute,
+  async (c) => {
+    const { source } = c.req.valid("query");
+    const skills = await listUserSkills(source);
+    return c.json({ skills }, 200);
+  },
+  (result, c) => {
+    if (!result.success) {
+      return c.json({ error: { message: "source must be 'custom' or 'official'" } }, 400);
+    }
   }
-  try {
-    const skills = await getUserSkillStatuses(skillIds);
-    return c.json({ skills });
-  } catch (error) {
-    return jsonError(error);
+);
+var getSkillStatusesRoute = createRoute11({
+  method: "post",
+  path: "/skills/status",
+  operationId: "getSkillStatuses",
+  request: {
+    body: {
+      required: true,
+      content: { "application/json": { schema: SkillStatusesBodySchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Get skill scan statuses",
+      content: { "application/json": { schema: SkillStatusesResponseSchema } }
+    },
+    ...errorResponses
   }
 });
-skillsRoute.delete("/skills/:id", async (c) => {
-  const id = c.req.param("id");
-  if (!id) {
-    return c.json({ error: { message: "skill id is required" } }, 400);
+skillsRoute.openapi(
+  getSkillStatusesRoute,
+  async (c) => {
+    const { skillIds } = c.req.valid("json");
+    const skills = await getUserSkillStatuses(skillIds);
+    return c.json({ skills }, 200);
+  },
+  (result, c) => {
+    if (!result.success) return c.json({ error: { message: "skillIds (string[]) is required" } }, 400);
   }
-  try {
-    await deleteUserSkill(id);
-    return c.body(null, 204);
-  } catch (error) {
-    return jsonError(error);
+);
+var deleteSkillRoute = createRoute11({
+  method: "delete",
+  path: "/skills/{id}",
+  operationId: "deleteSkill",
+  request: { params: SkillParamsSchema },
+  responses: {
+    204: { description: "Skill deleted" },
+    ...errorResponses
   }
 });
+skillsRoute.openapi(deleteSkillRoute, async (c) => {
+  const { id } = c.req.valid("param");
+  await deleteUserSkill(id);
+  return c.body(null, 204);
+});
 
 // ../../apps/server/src/routes/vaults.ts
-import { createRoute as createRoute10, OpenAPIHono as OpenAPIHono12 } from "@hono/zod-openapi";
+import { createRoute as createRoute12, OpenAPIHono as OpenAPIHono12 } from "@hono/zod-openapi";
 import { createCloudVault, deleteCloudVault, listCloudVaults } from "@openagentpack/sdk";
 
 // ../../apps/server/src/schemas/vaults.ts
-import { z as z8 } from "@hono/zod-openapi";
+import { z as z10 } from "@hono/zod-openapi";
 import { CloudVaultSchema } from "@openagentpack/sdk";
 import { CloudVaultSchema as CloudVaultSchema2 } from "@openagentpack/sdk";
-var CloudVaultsResponseSchema = z8.object({
-  vaults: z8.array(CloudVaultSchema)
+var CloudVaultsResponseSchema = z10.object({
+  vaults: z10.array(CloudVaultSchema)
 });
-var CreateVaultBodySchema = z8.object({
-  name: z8.string().min(1),
-  metadata: z8.record(z8.string(), z8.string()).optional(),
+var CreateVaultBodySchema = z10.object({
+  name: z10.string().min(1),
+  metadata: z10.record(z10.string(), z10.string()).optional(),
   // The DASHSCOPE_API_KEY stored as the vault's credential secret value. Optional: Mode B
   // supplies the user's key; Mode A (local) omits it and the server injects it from its own
   // DASHSCOPE_API_KEY env. (Mode B never reaches this REST route — it goes via console RPC.)
-  key: z8.string().min(1).optional()
+  key: z10.string().min(1).optional()
 });
-var CreateVaultResponseSchema = z8.object({
-  id: z8.string().nullable(),
-  type: z8.string(),
-  version: z8.number().optional()
+var CreateVaultResponseSchema = z10.object({
+  id: z10.string().nullable(),
+  type: z10.string(),
+  version: z10.number().optional()
 });
-var DeleteVaultResponseSchema = z8.object({
-  id: z8.string(),
-  type: z8.string()
+var DeleteVaultResponseSchema = z10.object({
+  id: z10.string(),
+  type: z10.string()
 });
-var VaultParamsSchema = z8.object({
-  vaultId: z8.string().min(1)
+var VaultParamsSchema = z10.object({
+  vaultId: z10.string().min(1)
 });
 
 // ../../apps/server/src/routes/vaults.ts
 var vaultsRoute = new OpenAPIHono12();
-var listVaultsRoute = createRoute10({
+var listVaultsRoute = createRoute12({
   method: "get",
   path: "/vaults",
   responses: {
@@ -3191,7 +3382,7 @@ vaultsRoute.openapi(listVaultsRoute, async (c) => {
   const vaults = await withAgentRuntime(DEFAULT_AGENT_ID, (ctx) => listCloudVaults(ctx));
   return c.json({ vaults }, 200);
 });
-var createVaultRoute = createRoute10({
+var createVaultRoute = createRoute12({
   method: "post",
   path: "/vaults",
   request: {
@@ -3234,7 +3425,7 @@ vaultsRoute.openapi(createVaultRoute, async (c) => {
   );
   return c.json(vault, 200);
 });
-var deleteVaultRoute = createRoute10({
+var deleteVaultRoute = createRoute12({
   method: "delete",
   path: "/vaults/{vaultId}",
   request: {
@@ -3327,7 +3518,11 @@ function injectPlaygroundRuntimeMarker(html) {
   return html.replace("<head>", '<head>\n    <meta name="agents-runtime" content="playground" />');
 }
 async function startServer() {
+  const cliProvider = process.env.AGENTS_CLI_PROVIDER?.trim();
   await bootstrapRuntimeCredentials2();
+  if (cliProvider) {
+    process.env.AGENTS_PROVIDER = cliProvider;
+  }
   const preferred = Number(process.env.PORT ?? DEFAULT_PLAYGROUND_PORT);
   const port = await resolveListenPort(preferred);
   if (port !== preferred) {