@meetkai/mka1 0.54.22 → 0.54.23

package/bin/mcp-server.js

@@ -52917,9 +52917,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.1.0",
-    sdkVersion: "0.54.22",
+    sdkVersion: "0.54.23",
     genVersion: "2.935.1",
-    userAgent: "speakeasy-sdk/typescript 0.54.22 2.935.1 1.1.0 @meetkai/mka1"
+    userAgent: "speakeasy-sdk/typescript 0.54.23 2.935.1 1.1.0 @meetkai/mka1"
   };
 });
 
@@ -75039,6 +75039,318 @@ var init_responserefusaldoneevent = __esm(() => {
   });
 });
 
+// src/models/components/responsescreaterequest.ts
+var Include, ResponsesCreateRequestTruncation, ResponsesCreateRequestServiceTier, Modalities, ResponsesCreateRequestFormat, ResponsesCreateRequestInput$inboundSchema, ResponsesCreateRequestInput$outboundSchema, ResponsesCreateRequestConversation$inboundSchema, ResponsesCreateRequestConversation$outboundSchema, Include$inboundSchema, Include$outboundSchema, ResponsesCreateRequestStreamOptions$inboundSchema, ResponsesCreateRequestStreamOptions$outboundSchema, Tools$inboundSchema, Tools$outboundSchema, ResponsesCreateRequestStop$inboundSchema, ResponsesCreateRequestStop$outboundSchema, ResponsesCreateRequestPrefillThink$inboundSchema, ResponsesCreateRequestPrefillThink$outboundSchema, ResponsesCreateRequestTruncation$inboundSchema, ResponsesCreateRequestTruncation$outboundSchema, ResponsesCreateRequestServiceTier$inboundSchema, ResponsesCreateRequestServiceTier$outboundSchema, Modalities$inboundSchema, Modalities$outboundSchema, ResponsesCreateRequestFormat$inboundSchema, ResponsesCreateRequestFormat$outboundSchema, Audio$inboundSchema, Audio$outboundSchema, ResponsesCreateRequest$inboundSchema, ResponsesCreateRequest$outboundSchema;
+var init_responsescreaterequest = __esm(() => {
+  init_esm();
+  init_primitives();
+  init_codeinterpretertooldefinition();
+  init_compactioncontextmanagement();
+  init_computerusetooldefinition();
+  init_conversation();
+  init_customtooldefinition();
+  init_filesearchtooldefinition();
+  init_functiontooldefinition();
+  init_historytooldefinition();
+  init_hostedtooldefinition();
+  init_imagegenerationtooldefinition();
+  init_item();
+  init_localshelltooldefinition();
+  init_mcptooldefinition();
+  init_prompttemplate();
+  init_reasoningconfiguration();
+  init_shelltooldefinition();
+  init_sleeptooldefinition();
+  init_textconfiguration();
+  init_toolchoice();
+  init_websearchpreviewtooldefinition();
+  init_websearchtooldefinition();
+  Include = {
+    WebSearchCallActionSources: "web_search_call.action.sources",
+    CodeInterpreterCallOutputs: "code_interpreter_call.outputs",
+    ComputerCallOutputOutputImageUrl: "computer_call_output.output.image_url",
+    FileSearchCallResults: "file_search_call.results",
+    MessageInputImageImageUrl: "message.input_image.image_url",
+    MessageOutputTextLogprobs: "message.output_text.logprobs",
+    ReasoningEncryptedContent: "reasoning.encrypted_content"
+  };
+  ResponsesCreateRequestTruncation = {
+    Auto: "auto",
+    Disabled: "disabled"
+  };
+  ResponsesCreateRequestServiceTier = {
+    Auto: "auto",
+    Default: "default",
+    Flex: "flex",
+    Priority: "priority"
+  };
+  Modalities = {
+    Text: "text",
+    Audio: "audio"
+  };
+  ResponsesCreateRequestFormat = {
+    Wav: "wav",
+    Mp3: "mp3",
+    Flac: "flac",
+    Opus: "opus",
+    Pcm16: "pcm16"
+  };
+  ResponsesCreateRequestInput$inboundSchema = unionType([stringType(), arrayType(Item$inboundSchema)]);
+  ResponsesCreateRequestInput$outboundSchema = unionType([stringType(), arrayType(Item$outboundSchema)]);
+  ResponsesCreateRequestConversation$inboundSchema = unionType([Conversation$inboundSchema, stringType()]);
+  ResponsesCreateRequestConversation$outboundSchema = unionType([Conversation$outboundSchema, stringType()]);
+  Include$inboundSchema = nativeEnumType(Include);
+  Include$outboundSchema = Include$inboundSchema;
+  ResponsesCreateRequestStreamOptions$inboundSchema = objectType({
+    include_usage: booleanType().optional(),
+    include_obfuscation: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      include_usage: "includeUsage",
+      include_obfuscation: "includeObfuscation"
+    });
+  });
+  ResponsesCreateRequestStreamOptions$outboundSchema = objectType({
+    includeUsage: booleanType().optional(),
+    includeObfuscation: booleanType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      includeUsage: "include_usage",
+      includeObfuscation: "include_obfuscation"
+    });
+  });
+  Tools$inboundSchema = unionType([
+    FunctionToolDefinition$inboundSchema,
+    ComputerUseToolDefinition$inboundSchema,
+    FileSearchToolDefinition$inboundSchema,
+    CodeInterpreterToolDefinition$inboundSchema,
+    CustomToolDefinition$inboundSchema,
+    WebSearchToolDefinition$inboundSchema,
+    MCPToolDefinition$inboundSchema,
+    ImageGenerationToolDefinition$inboundSchema,
+    LocalShellToolDefinition$inboundSchema,
+    ShellToolDefinition$inboundSchema,
+    WebSearchPreviewToolDefinition$inboundSchema,
+    HostedToolDefinition$inboundSchema,
+    SleepToolDefinition$inboundSchema,
+    HistoryToolDefinition$inboundSchema
+  ]);
+  Tools$outboundSchema = unionType([
+    FunctionToolDefinition$outboundSchema,
+    ComputerUseToolDefinition$outboundSchema,
+    FileSearchToolDefinition$outboundSchema,
+    CodeInterpreterToolDefinition$outboundSchema,
+    CustomToolDefinition$outboundSchema,
+    WebSearchToolDefinition$outboundSchema,
+    MCPToolDefinition$outboundSchema,
+    ImageGenerationToolDefinition$outboundSchema,
+    LocalShellToolDefinition$outboundSchema,
+    ShellToolDefinition$outboundSchema,
+    WebSearchPreviewToolDefinition$outboundSchema,
+    HostedToolDefinition$outboundSchema,
+    SleepToolDefinition$outboundSchema,
+    HistoryToolDefinition$outboundSchema
+  ]);
+  ResponsesCreateRequestStop$inboundSchema = unionType([stringType(), arrayType(stringType())]);
+  ResponsesCreateRequestStop$outboundSchema = unionType([stringType(), arrayType(stringType())]);
+  ResponsesCreateRequestPrefillThink$inboundSchema = unionType([booleanType(), stringType()]);
+  ResponsesCreateRequestPrefillThink$outboundSchema = unionType([booleanType(), stringType()]);
+  ResponsesCreateRequestTruncation$inboundSchema = nativeEnumType(ResponsesCreateRequestTruncation);
+  ResponsesCreateRequestTruncation$outboundSchema = ResponsesCreateRequestTruncation$inboundSchema;
+  ResponsesCreateRequestServiceTier$inboundSchema = nativeEnumType(ResponsesCreateRequestServiceTier);
+  ResponsesCreateRequestServiceTier$outboundSchema = ResponsesCreateRequestServiceTier$inboundSchema;
+  Modalities$inboundSchema = nativeEnumType(Modalities);
+  Modalities$outboundSchema = Modalities$inboundSchema;
+  ResponsesCreateRequestFormat$inboundSchema = nativeEnumType(ResponsesCreateRequestFormat);
+  ResponsesCreateRequestFormat$outboundSchema = ResponsesCreateRequestFormat$inboundSchema;
+  Audio$inboundSchema = objectType({
+    voice: stringType().default("alloy"),
+    format: ResponsesCreateRequestFormat$inboundSchema.default("wav")
+  });
+  Audio$outboundSchema = objectType({
+    voice: stringType().default("alloy"),
+    format: ResponsesCreateRequestFormat$outboundSchema.default("wav")
+  });
+  ResponsesCreateRequest$inboundSchema = objectType({
+    model: stringType(),
+    input: unionType([stringType(), arrayType(Item$inboundSchema)]).optional(),
+    instructions: stringType().optional(),
+    conversation: nullableType(unionType([Conversation$inboundSchema, stringType()])).optional(),
+    previous_response_id: stringType().optional(),
+    prompt: PromptTemplate$inboundSchema.optional(),
+    include: arrayType(Include$inboundSchema).optional(),
+    text: TextConfiguration$inboundSchema.optional(),
+    stream: booleanType().default(false),
+    stream_options: nullableType(lazyType(() => ResponsesCreateRequestStreamOptions$inboundSchema)).optional(),
+    stream_events: booleanType().optional(),
+    store: booleanType().default(true),
+    background: booleanType().default(false),
+    webhook_url: stringType().optional(),
+    webhook_secret: stringType().optional(),
+    tools: arrayType(unionType([
+      FunctionToolDefinition$inboundSchema,
+      ComputerUseToolDefinition$inboundSchema,
+      FileSearchToolDefinition$inboundSchema,
+      CodeInterpreterToolDefinition$inboundSchema,
+      CustomToolDefinition$inboundSchema,
+      WebSearchToolDefinition$inboundSchema,
+      MCPToolDefinition$inboundSchema,
+      ImageGenerationToolDefinition$inboundSchema,
+      LocalShellToolDefinition$inboundSchema,
+      ShellToolDefinition$inboundSchema,
+      WebSearchPreviewToolDefinition$inboundSchema,
+      HostedToolDefinition$inboundSchema,
+      SleepToolDefinition$inboundSchema,
+      HistoryToolDefinition$inboundSchema
+    ])).optional(),
+    tool_choice: ToolChoice$inboundSchema.optional(),
+    parallel_tool_calls: booleanType().default(true),
+    max_tool_calls: numberType().int().default(64),
+    reasoning: ReasoningConfiguration$inboundSchema.optional(),
+    max_output_tokens: numberType().int().optional(),
+    temperature: numberType().optional(),
+    top_p: numberType().optional(),
+    stop: unionType([stringType(), arrayType(stringType())]).optional(),
+    top_k: numberType().int().optional(),
+    min_p: numberType().optional(),
+    repetition_penalty: numberType().optional(),
+    do_sample: booleanType().optional(),
+    extra_body: recordType(anyType()).optional(),
+    chat_template_kwargs: recordType(anyType()).optional(),
+    prefill_think: unionType([booleanType(), stringType()]).optional(),
+    use_cache: booleanType().optional(),
+    top_logprobs: numberType().int().optional(),
+    truncation: ResponsesCreateRequestTruncation$inboundSchema.default("auto"),
+    context_management: arrayType(CompactionContextManagement$inboundSchema).optional(),
+    presence_penalty: numberType().optional(),
+    frequency_penalty: numberType().optional(),
+    service_tier: ResponsesCreateRequestServiceTier$inboundSchema.default("auto"),
+    prompt_cache_key: stringType().optional(),
+    safety_identifier: stringType().optional(),
+    metadata: recordType(stringType()).optional(),
+    modalities: arrayType(Modalities$inboundSchema).optional(),
+    audio: lazyType(() => Audio$inboundSchema).optional(),
+    user: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      previous_response_id: "previousResponseId",
+      stream_options: "streamOptions",
+      stream_events: "streamEvents",
+      webhook_url: "webhookUrl",
+      webhook_secret: "webhookSecret",
+      tool_choice: "toolChoice",
+      parallel_tool_calls: "parallelToolCalls",
+      max_tool_calls: "maxToolCalls",
+      max_output_tokens: "maxOutputTokens",
+      top_p: "topP",
+      top_k: "topK",
+      min_p: "minP",
+      repetition_penalty: "repetitionPenalty",
+      do_sample: "doSample",
+      extra_body: "extraBody",
+      chat_template_kwargs: "chatTemplateKwargs",
+      prefill_think: "prefillThink",
+      use_cache: "useCache",
+      top_logprobs: "topLogprobs",
+      context_management: "contextManagement",
+      presence_penalty: "presencePenalty",
+      frequency_penalty: "frequencyPenalty",
+      service_tier: "serviceTier",
+      prompt_cache_key: "promptCacheKey",
+      safety_identifier: "safetyIdentifier"
+    });
+  });
+  ResponsesCreateRequest$outboundSchema = objectType({
+    model: stringType(),
+    input: unionType([stringType(), arrayType(Item$outboundSchema)]).optional(),
+    instructions: stringType().optional(),
+    conversation: nullableType(unionType([Conversation$outboundSchema, stringType()])).optional(),
+    previousResponseId: stringType().optional(),
+    prompt: PromptTemplate$outboundSchema.optional(),
+    include: arrayType(Include$outboundSchema).optional(),
+    text: TextConfiguration$outboundSchema.optional(),
+    stream: booleanType().default(false),
+    streamOptions: nullableType(lazyType(() => ResponsesCreateRequestStreamOptions$outboundSchema)).optional(),
+    streamEvents: booleanType().optional(),
+    store: booleanType().default(true),
+    background: booleanType().default(false),
+    webhookUrl: stringType().optional(),
+    webhookSecret: stringType().optional(),
+    tools: arrayType(unionType([
+      FunctionToolDefinition$outboundSchema,
+      ComputerUseToolDefinition$outboundSchema,
+      FileSearchToolDefinition$outboundSchema,
+      CodeInterpreterToolDefinition$outboundSchema,
+      CustomToolDefinition$outboundSchema,
+      WebSearchToolDefinition$outboundSchema,
+      MCPToolDefinition$outboundSchema,
+      ImageGenerationToolDefinition$outboundSchema,
+      LocalShellToolDefinition$outboundSchema,
+      ShellToolDefinition$outboundSchema,
+      WebSearchPreviewToolDefinition$outboundSchema,
+      HostedToolDefinition$outboundSchema,
+      SleepToolDefinition$outboundSchema,
+      HistoryToolDefinition$outboundSchema
+    ])).optional(),
+    toolChoice: ToolChoice$outboundSchema.optional(),
+    parallelToolCalls: booleanType().default(true),
+    maxToolCalls: numberType().int().default(64),
+    reasoning: ReasoningConfiguration$outboundSchema.optional(),
+    maxOutputTokens: numberType().int().optional(),
+    temperature: numberType().optional(),
+    topP: numberType().optional(),
+    stop: unionType([stringType(), arrayType(stringType())]).optional(),
+    topK: numberType().int().optional(),
+    minP: numberType().optional(),
+    repetitionPenalty: numberType().optional(),
+    doSample: booleanType().optional(),
+    extraBody: recordType(anyType()).optional(),
+    chatTemplateKwargs: recordType(anyType()).optional(),
+    prefillThink: unionType([booleanType(), stringType()]).optional(),
+    useCache: booleanType().optional(),
+    topLogprobs: numberType().int().optional(),
+    truncation: ResponsesCreateRequestTruncation$outboundSchema.default("auto"),
+    contextManagement: arrayType(CompactionContextManagement$outboundSchema).optional(),
+    presencePenalty: numberType().optional(),
+    frequencyPenalty: numberType().optional(),
+    serviceTier: ResponsesCreateRequestServiceTier$outboundSchema.default("auto"),
+    promptCacheKey: stringType().optional(),
+    safetyIdentifier: stringType().optional(),
+    metadata: recordType(stringType()).optional(),
+    modalities: arrayType(Modalities$outboundSchema).optional(),
+    audio: lazyType(() => Audio$outboundSchema).optional(),
+    user: stringType().optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      previousResponseId: "previous_response_id",
+      streamOptions: "stream_options",
+      streamEvents: "stream_events",
+      webhookUrl: "webhook_url",
+      webhookSecret: "webhook_secret",
+      toolChoice: "tool_choice",
+      parallelToolCalls: "parallel_tool_calls",
+      maxToolCalls: "max_tool_calls",
+      maxOutputTokens: "max_output_tokens",
+      topP: "top_p",
+      topK: "top_k",
+      minP: "min_p",
+      repetitionPenalty: "repetition_penalty",
+      doSample: "do_sample",
+      extraBody: "extra_body",
+      chatTemplateKwargs: "chat_template_kwargs",
+      prefillThink: "prefill_think",
+      useCache: "use_cache",
+      topLogprobs: "top_logprobs",
+      contextManagement: "context_management",
+      presencePenalty: "presence_penalty",
+      frequencyPenalty: "frequency_penalty",
+      serviceTier: "service_tier",
+      promptCacheKey: "prompt_cache_key",
+      safetyIdentifier: "safety_identifier"
+    });
+  });
+});
+
 // src/models/components/responsesgroupby.ts
 var ResponsesGroupBy, ResponsesGroupBy$inboundSchema, ResponsesGroupBy$outboundSchema;
 var init_responsesgroupby = __esm(() => {
@@ -79415,6 +79727,7 @@ var init_components = __esm(() => {
   init_responsereasoningtextdoneevent();
   init_responserefusaldeltaevent();
   init_responserefusaldoneevent();
+  init_responsescreaterequest();
   init_responsesgroupby();
   init_responseshellcallcompletedevent();
   init_responseshellcallexecutingevent();
@@ -89491,6 +89804,221 @@ var init_createrepo = __esm(() => {
   });
 });
 
+// src/lib/event-streams.ts
+function findBoundary(buf, len, from) {
+  for (let i = from;i < len; i++) {
+    if (buf[i] !== CR && buf[i] !== LF)
+      continue;
+    for (const boundary of BOUNDARIES) {
+      if (i + boundary.length > len)
+        continue;
+      let match2 = true;
+      for (let j2 = 0;j2 < boundary.length; j2++) {
+        if (buf[i + j2] !== boundary[j2]) {
+          match2 = false;
+          break;
+        }
+      }
+      if (match2)
+        return { index: i, length: boundary.length };
+    }
+  }
+  return null;
+}
+function parseMessage(chunk, parse6, state, dataRequired) {
+  const text2 = new TextDecoder().decode(chunk);
+  const lines = text2.split(/\r\n|\r|\n/);
+  const dataLines = [];
+  const ret = {};
+  let ignore = true;
+  for (const line of lines) {
+    if (!line || line.startsWith(":"))
+      continue;
+    ignore = false;
+    const i = line.indexOf(":");
+    let field = line;
+    let value = "";
+    if (i > 0) {
+      field = line.slice(0, i);
+      value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
+    }
+    if (field === "data")
+      dataLines.push(value);
+    else if (field === "event")
+      ret.event = value;
+    else if (field === "id" && !value.includes("\x00"))
+      state.eventId = value;
+    else if (field === "retry" && /^\d+$/.test(value)) {
+      ret.retry = Number(value);
+    }
+  }
+  if (ignore)
+    return;
+  ret.id = state.eventId;
+  if (dataLines.length)
+    ret.data = dataLines.join(`
+`);
+  else if (dataRequired)
+    return;
+  return parse6(ret);
+}
+var EventStream, CR = 13, LF = 10, BOUNDARIES, MAX_BOUNDARY_LEN;
+var init_event_streams = __esm(() => {
+  EventStream = class EventStream extends ReadableStream {
+    constructor(responseBody, parse6, opts) {
+      const upstream = responseBody.getReader();
+      let buffer = new Uint8Array(4096);
+      let bufferLen = 0;
+      let searchStart = 0;
+      const state = { eventId: undefined };
+      const dataRequired = opts?.dataRequired ?? true;
+      super({
+        async pull(downstream) {
+          try {
+            while (true) {
+              const match2 = findBoundary(buffer, bufferLen, searchStart);
+              if (!match2) {
+                searchStart = Math.max(0, bufferLen - MAX_BOUNDARY_LEN + 1);
+                const chunk = await upstream.read();
+                if (chunk.done)
+                  return downstream.close();
+                if (bufferLen + chunk.value.length > buffer.length) {
+                  const grown = new Uint8Array(Math.max(buffer.length * 2, bufferLen + chunk.value.length));
+                  grown.set(buffer.subarray(0, bufferLen));
+                  buffer = grown;
+                }
+                buffer.set(chunk.value, bufferLen);
+                bufferLen += chunk.value.length;
+                continue;
+              }
+              const message = buffer.slice(0, match2.index);
+              buffer.copyWithin(0, match2.index + match2.length, bufferLen);
+              bufferLen -= match2.index + match2.length;
+              if (buffer.length > 4096 && bufferLen <= buffer.length >> 2) {
+                const shrunk = new Uint8Array(Math.max(4096, bufferLen * 2));
+                shrunk.set(buffer.subarray(0, bufferLen));
+                buffer = shrunk;
+              }
+              searchStart = 0;
+              const item2 = parseMessage(message, parse6, state, dataRequired);
+              if (item2 && !item2.done)
+                return downstream.enqueue(item2.value);
+              if (item2?.done) {
+                await upstream.cancel("done");
+                return downstream.close();
+              }
+            }
+          } catch (e) {
+            downstream.error(e);
+            await upstream.cancel(e);
+          }
+        },
+        cancel: (reason) => upstream.cancel(reason)
+      });
+    }
+    [Symbol.asyncIterator]() {
+      const fn = ReadableStream.prototype[Symbol.asyncIterator];
+      if (typeof fn === "function")
+        return fn.call(this);
+      const reader = this.getReader();
+      return {
+        next: async () => {
+          const r = await reader.read();
+          if (r.done) {
+            reader.releaseLock();
+            return { done: true, value: undefined };
+          }
+          return { done: false, value: r.value };
+        },
+        throw: async (e) => {
+          await reader.cancel(e);
+          reader.releaseLock();
+          return { done: true, value: undefined };
+        },
+        return: async () => {
+          await reader.cancel("done");
+          reader.releaseLock();
+          return { done: true, value: undefined };
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+    }
+  };
+  BOUNDARIES = [
+    [CR, LF, CR, LF],
+    [CR, LF, CR],
+    [CR, LF, LF],
+    [CR, CR, LF],
+    [LF, CR, LF],
+    [CR, CR],
+    [LF, CR],
+    [LF, LF]
+  ];
+  MAX_BOUNDARY_LEN = BOUNDARIES.reduce((m, b2) => Math.max(m, b2.length), 0);
+});
+
+// src/models/operations/createresponse.ts
+var CreateResponseRequest$inboundSchema, CreateResponseRequest$outboundSchema, CreateResponseResponseBody$inboundSchema, CreateResponseResponseBody$outboundSchema, CreateResponseResponse$inboundSchema, CreateResponseResponse$outboundSchema;
+var init_createresponse = __esm(() => {
+  init_esm();
+  init_event_streams();
+  init_primitives();
+  init_components();
+  CreateResponseRequest$inboundSchema = objectType({
+    "X-On-Behalf-Of": stringType().optional(),
+    ResponsesCreateRequest: ResponsesCreateRequest$inboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      "X-On-Behalf-Of": "xOnBehalfOf",
+      ResponsesCreateRequest: "responsesCreateRequest"
+    });
+  });
+  CreateResponseRequest$outboundSchema = objectType({
+    xOnBehalfOf: stringType().optional(),
+    responsesCreateRequest: ResponsesCreateRequest$outboundSchema
+  }).transform((v2) => {
+    return remap(v2, {
+      xOnBehalfOf: "X-On-Behalf-Of",
+      responsesCreateRequest: "ResponsesCreateRequest"
+    });
+  });
+  CreateResponseResponseBody$inboundSchema = objectType({
+    event: stringType().optional(),
+    data: unknownType().transform((v2, ctx) => {
+      if (typeof v2 !== "string")
+        return v2;
+      try {
+        return JSON.parse(v2);
+      } catch (err) {
+        ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+        return NEVER;
+      }
+    }).pipe(ResponseStreamingEvent$inboundSchema),
+    id: stringType().optional(),
+    retry: numberType().int().optional()
+  });
+  CreateResponseResponseBody$outboundSchema = objectType({
+    event: stringType().optional(),
+    data: ResponseStreamingEvent$outboundSchema,
+    id: stringType().optional(),
+    retry: numberType().int().optional()
+  });
+  CreateResponseResponse$inboundSchema = unionType([
+    ResponseObject$inboundSchema,
+    instanceOfType(ReadableStream).transform((stream2) => {
+      return new EventStream(stream2, (rawEvent) => {
+        return {
+          done: false,
+          value: lazyType(() => CreateResponseResponseBody$inboundSchema).parse(rawEvent)
+        };
+      });
+    })
+  ]);
+  CreateResponseResponse$outboundSchema = unionType([ResponseObject$outboundSchema, neverType()]);
+});
+
 // src/models/operations/createresponsefeedback.ts
 var CreateResponseFeedbackRequest$inboundSchema, CreateResponseFeedbackRequest$outboundSchema;
 var init_createresponsefeedback = __esm(() => {
@@ -94967,169 +95495,14 @@ var init_getrepo = __esm(() => {
   });
 });
 
-// src/lib/event-streams.ts
-function findBoundary(buf, len, from) {
-  for (let i = from;i < len; i++) {
-    if (buf[i] !== CR && buf[i] !== LF)
-      continue;
-    for (const boundary of BOUNDARIES) {
-      if (i + boundary.length > len)
-        continue;
-      let match2 = true;
-      for (let j2 = 0;j2 < boundary.length; j2++) {
-        if (buf[i + j2] !== boundary[j2]) {
-          match2 = false;
-          break;
-        }
-      }
-      if (match2)
-        return { index: i, length: boundary.length };
-    }
-  }
-  return null;
-}
-function parseMessage(chunk, parse6, state, dataRequired) {
-  const text2 = new TextDecoder().decode(chunk);
-  const lines = text2.split(/\r\n|\r|\n/);
-  const dataLines = [];
-  const ret = {};
-  let ignore = true;
-  for (const line of lines) {
-    if (!line || line.startsWith(":"))
-      continue;
-    ignore = false;
-    const i = line.indexOf(":");
-    let field = line;
-    let value = "";
-    if (i > 0) {
-      field = line.slice(0, i);
-      value = line[i + 1] === " " ? line.slice(i + 2) : line.slice(i + 1);
-    }
-    if (field === "data")
-      dataLines.push(value);
-    else if (field === "event")
-      ret.event = value;
-    else if (field === "id" && !value.includes("\x00"))
-      state.eventId = value;
-    else if (field === "retry" && /^\d+$/.test(value)) {
-      ret.retry = Number(value);
-    }
-  }
-  if (ignore)
-    return;
-  ret.id = state.eventId;
-  if (dataLines.length)
-    ret.data = dataLines.join(`
-`);
-  else if (dataRequired)
-    return;
-  return parse6(ret);
-}
-var EventStream, CR = 13, LF = 10, BOUNDARIES, MAX_BOUNDARY_LEN;
-var init_event_streams = __esm(() => {
-  EventStream = class EventStream extends ReadableStream {
-    constructor(responseBody, parse6, opts) {
-      const upstream = responseBody.getReader();
-      let buffer = new Uint8Array(4096);
-      let bufferLen = 0;
-      let searchStart = 0;
-      const state = { eventId: undefined };
-      const dataRequired = opts?.dataRequired ?? true;
-      super({
-        async pull(downstream) {
-          try {
-            while (true) {
-              const match2 = findBoundary(buffer, bufferLen, searchStart);
-              if (!match2) {
-                searchStart = Math.max(0, bufferLen - MAX_BOUNDARY_LEN + 1);
-                const chunk = await upstream.read();
-                if (chunk.done)
-                  return downstream.close();
-                if (bufferLen + chunk.value.length > buffer.length) {
-                  const grown = new Uint8Array(Math.max(buffer.length * 2, bufferLen + chunk.value.length));
-                  grown.set(buffer.subarray(0, bufferLen));
-                  buffer = grown;
-                }
-                buffer.set(chunk.value, bufferLen);
-                bufferLen += chunk.value.length;
-                continue;
-              }
-              const message = buffer.slice(0, match2.index);
-              buffer.copyWithin(0, match2.index + match2.length, bufferLen);
-              bufferLen -= match2.index + match2.length;
-              if (buffer.length > 4096 && bufferLen <= buffer.length >> 2) {
-                const shrunk = new Uint8Array(Math.max(4096, bufferLen * 2));
-                shrunk.set(buffer.subarray(0, bufferLen));
-                buffer = shrunk;
-              }
-              searchStart = 0;
-              const item2 = parseMessage(message, parse6, state, dataRequired);
-              if (item2 && !item2.done)
-                return downstream.enqueue(item2.value);
-              if (item2?.done) {
-                await upstream.cancel("done");
-                return downstream.close();
-              }
-            }
-          } catch (e) {
-            downstream.error(e);
-            await upstream.cancel(e);
-          }
-        },
-        cancel: (reason) => upstream.cancel(reason)
-      });
-    }
-    [Symbol.asyncIterator]() {
-      const fn = ReadableStream.prototype[Symbol.asyncIterator];
-      if (typeof fn === "function")
-        return fn.call(this);
-      const reader = this.getReader();
-      return {
-        next: async () => {
-          const r = await reader.read();
-          if (r.done) {
-            reader.releaseLock();
-            return { done: true, value: undefined };
-          }
-          return { done: false, value: r.value };
-        },
-        throw: async (e) => {
-          await reader.cancel(e);
-          reader.releaseLock();
-          return { done: true, value: undefined };
-        },
-        return: async () => {
-          await reader.cancel("done");
-          reader.releaseLock();
-          return { done: true, value: undefined };
-        },
-        [Symbol.asyncIterator]() {
-          return this;
-        }
-      };
-    }
-  };
-  BOUNDARIES = [
-    [CR, LF, CR, LF],
-    [CR, LF, CR],
-    [CR, LF, LF],
-    [CR, CR, LF],
-    [LF, CR, LF],
-    [CR, CR],
-    [LF, CR],
-    [LF, LF]
-  ];
-  MAX_BOUNDARY_LEN = BOUNDARIES.reduce((m, b2) => Math.max(m, b2.length), 0);
-});
-
 // src/models/operations/getresponse.ts
-var Include, Include$inboundSchema, Include$outboundSchema, GetResponseRequest$inboundSchema, GetResponseRequest$outboundSchema, GetResponseResponseBody$inboundSchema, GetResponseResponseBody$outboundSchema, GetResponseResponse$inboundSchema, GetResponseResponse$outboundSchema;
+var Include2, Include$inboundSchema2, Include$outboundSchema2, GetResponseRequest$inboundSchema, GetResponseRequest$outboundSchema, GetResponseResponseBody$inboundSchema, GetResponseResponseBody$outboundSchema, GetResponseResponse$inboundSchema, GetResponseResponse$outboundSchema;
 var init_getresponse = __esm(() => {
   init_esm();
   init_event_streams();
   init_primitives();
   init_components();
-  Include = {
+  Include2 = {
     WebSearchCallActionSources: "web_search_call.action.sources",
     CodeInterpreterCallOutputs: "code_interpreter_call.outputs",
     ComputerCallOutputOutputImageUrl: "computer_call_output.output.image_url",
@@ -95138,11 +95511,11 @@ var init_getresponse = __esm(() => {
     MessageOutputTextLogprobs: "message.output_text.logprobs",
     ReasoningEncryptedContent: "reasoning.encrypted_content"
   };
-  Include$inboundSchema = nativeEnumType(Include);
-  Include$outboundSchema = Include$inboundSchema;
+  Include$inboundSchema2 = nativeEnumType(Include2);
+  Include$outboundSchema2 = Include$inboundSchema2;
   GetResponseRequest$inboundSchema = objectType({
     response_id: stringType(),
-    include: arrayType(Include$inboundSchema).optional(),
+    include: arrayType(Include$inboundSchema2).optional(),
     include_obfuscation: booleanType().optional(),
     starting_after: numberType().int().optional(),
     stream: booleanType().optional(),
@@ -95157,7 +95530,7 @@ var init_getresponse = __esm(() => {
   });
   GetResponseRequest$outboundSchema = objectType({
     responseId: stringType(),
-    include: arrayType(Include$outboundSchema).optional(),
+    include: arrayType(Include$outboundSchema2).optional(),
     includeObfuscation: booleanType().optional(),
     startingAfter: numberType().int().optional(),
     stream: booleanType().optional(),
@@ -106088,6 +106461,7 @@ var init_operations = __esm(() => {
   init_createprompt();
   init_createpromptversion();
   init_createrepo();
+  init_createresponse();
   init_createresponsefeedback();
   init_createscopedapikey2();
   init_createservice();
@@ -138360,11 +138734,123 @@ Creates a compacted summary of the conversation history for a response, reducing
   };
 });
 
-// src/funcs/llmResponsesDelete.ts
-function llmResponsesDelete(client, request, options) {
+// src/funcs/llmResponsesCreate.ts
+function llmResponsesCreate(client, request, options) {
   return new APIPromise($do275(client, request, options));
 }
 async function $do275(client, request, options) {
+  const parsed = safeParse4(request, (value) => CreateResponseRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload.ResponsesCreateRequest, {
+    explode: true
+  });
+  const path = pathToFunc("/api/v1/llm/responses")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: options?.acceptHeaderOverride || "application/json;q=1, text/event-stream;q=0",
+    "X-On-Behalf-Of": encodeSimple("X-On-Behalf-Of", payload["X-On-Behalf-Of"], { explode: false, charEncoding: "none" })
+  }));
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput, [0]);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "createResponse",
+    oAuth2Scopes: null,
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries || client._options.retryConfig || {
+      strategy: "backoff",
+      backoff: {
+        initialInterval: 500,
+        maxInterval: 5000,
+        exponent: 1.5,
+        maxElapsedTime: 15000
+      },
+      retryConnectionErrors: true
+    },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 600000
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, CreateResponseResponse$inboundSchema), sse(200, CreateResponseResponse$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_llmResponsesCreate = __esm(() => {
+  init_encodings();
+  init_http();
+  init_matchers();
+  init_primitives();
+  init_schemas4();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/llmResponsesCreate.ts
+var args267, tool$llmResponsesCreate;
+var init_llmResponsesCreate2 = __esm(() => {
+  init_llmResponsesCreate();
+  init_operations();
+  init_tools();
+  args267 = {
+    request: CreateResponseRequest$inboundSchema
+  };
+  tool$llmResponsesCreate = {
+    name: "llm-responses-create",
+    description: `Create an agent-powered response with tool support
+
+Creates a new AI agent response using advanced language models with autonomous tool usage capabilities.`,
+    args: args267,
+    tool: async (client, args268, ctx) => {
+      const [result, apiCall] = await llmResponsesCreate(client, args268.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/llmResponsesDelete.ts
+function llmResponsesDelete(client, request, options) {
+  return new APIPromise($do276(client, request, options));
+}
+async function $do276(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138448,12 +138934,12 @@ var init_llmResponsesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/llmResponsesDelete.ts
-var args267, tool$llmResponsesDelete;
+var args268, tool$llmResponsesDelete;
 var init_llmResponsesDelete2 = __esm(() => {
   init_llmResponsesDelete();
   init_operations();
   init_tools();
-  args267 = {
+  args268 = {
     request: DeleteResponseRequest$inboundSchema
   };
   tool$llmResponsesDelete = {
@@ -138461,9 +138947,9 @@ var init_llmResponsesDelete2 = __esm(() => {
     description: `Permanently delete a response and its data
 
 Permanently deletes an agent response and all associated data.`,
-    args: args267,
-    tool: async (client, args268, ctx) => {
-      const [result, apiCall] = await llmResponsesDelete(client, args268.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args268,
+    tool: async (client, args269, ctx) => {
+      const [result, apiCall] = await llmResponsesDelete(client, args269.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138478,9 +138964,9 @@ Permanently deletes an agent response and all associated data.`,
 
 // src/funcs/llmResponsesGet.ts
 function llmResponsesGet(client, request, options) {
-  return new APIPromise($do276(client, request, options));
+  return new APIPromise($do277(client, request, options));
 }
-async function $do276(client, request, options) {
+async function $do277(client, request, options) {
   const parsed = safeParse4(request, (value) => GetResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138570,12 +139056,12 @@ var init_llmResponsesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/llmResponsesGet.ts
-var args268, tool$llmResponsesGet;
+var args269, tool$llmResponsesGet;
 var init_llmResponsesGet2 = __esm(() => {
   init_llmResponsesGet();
   init_operations();
   init_tools();
-  args268 = {
+  args269 = {
     request: GetResponseRequest$inboundSchema
   };
   tool$llmResponsesGet = {
@@ -138583,9 +139069,9 @@ var init_llmResponsesGet2 = __esm(() => {
     description: `Retrieve response by ID with status and results
 
 Retrieves a previously created agent response by its unique ID. When stream=true, returns Server-Sent Events for real-time updates on in-progress background responses.`,
-    args: args268,
-    tool: async (client, args269, ctx) => {
-      const [result, apiCall] = await llmResponsesGet(client, args269.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args269,
+    tool: async (client, args270, ctx) => {
+      const [result, apiCall] = await llmResponsesGet(client, args270.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138600,9 +139086,9 @@ Retrieves a previously created agent response by its unique ID. When stream=true
 
 // src/funcs/llmResponsesList.ts
 function llmResponsesList(client, request, options) {
-  return new APIPromise($do277(client, request, options));
+  return new APIPromise($do278(client, request, options));
 }
-async function $do277(client, request, options) {
+async function $do278(client, request, options) {
   const parsed = safeParse4(request, (value) => ListResponsesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138687,12 +139173,12 @@ var init_llmResponsesList = __esm(() => {
 });
 
 // src/mcp-server/tools/llmResponsesList.ts
-var args269, tool$llmResponsesList;
+var args270, tool$llmResponsesList;
 var init_llmResponsesList2 = __esm(() => {
   init_llmResponsesList();
   init_operations();
   init_tools();
-  args269 = {
+  args270 = {
     request: ListResponsesRequest$inboundSchema
   };
   tool$llmResponsesList = {
@@ -138700,9 +139186,9 @@ var init_llmResponsesList2 = __esm(() => {
     description: `List all responses with pagination
 
 Retrieves a paginated list of all agent responses for the authenticated user.`,
-    args: args269,
-    tool: async (client, args270, ctx) => {
-      const [result, apiCall] = await llmResponsesList(client, args270.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args270,
+    tool: async (client, args271, ctx) => {
+      const [result, apiCall] = await llmResponsesList(client, args271.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138717,9 +139203,9 @@ Retrieves a paginated list of all agent responses for the authenticated user.`,
 
 // src/funcs/llmResponsesListInputItems.ts
 function llmResponsesListInputItems(client, request, options) {
-  return new APIPromise($do278(client, request, options));
+  return new APIPromise($do279(client, request, options));
 }
-async function $do278(client, request, options) {
+async function $do279(client, request, options) {
   const parsed = safeParse4(request, (value) => ListInputItemsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138810,12 +139296,12 @@ var init_llmResponsesListInputItems = __esm(() => {
 });
 
 // src/mcp-server/tools/llmResponsesListInputItems.ts
-var args270, tool$llmResponsesListInputItems;
+var args271, tool$llmResponsesListInputItems;
 var init_llmResponsesListInputItems2 = __esm(() => {
   init_llmResponsesListInputItems();
   init_operations();
   init_tools();
-  args270 = {
+  args271 = {
     request: ListInputItemsRequest$inboundSchema
   };
   tool$llmResponsesListInputItems = {
@@ -138823,9 +139309,9 @@ var init_llmResponsesListInputItems2 = __esm(() => {
     description: `List paginated input items for a response
 
 Retrieves a paginated list of all input items provided when creating the specified agent response.`,
-    args: args270,
-    tool: async (client, args271, ctx) => {
-      const [result, apiCall] = await llmResponsesListInputItems(client, args271.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args271,
+    tool: async (client, args272, ctx) => {
+      const [result, apiCall] = await llmResponsesListInputItems(client, args272.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138840,9 +139326,9 @@ Retrieves a paginated list of all input items provided when creating the specifi
 
 // src/funcs/llmResponsesUpdate.ts
 function llmResponsesUpdate(client, request, options) {
-  return new APIPromise($do279(client, request, options));
+  return new APIPromise($do280(client, request, options));
 }
-async function $do279(client, request, options) {
+async function $do280(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateResponseRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -138929,12 +139415,12 @@ var init_llmResponsesUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/llmResponsesUpdate.ts
-var args271, tool$llmResponsesUpdate;
+var args272, tool$llmResponsesUpdate;
 var init_llmResponsesUpdate2 = __esm(() => {
   init_llmResponsesUpdate();
   init_operations();
   init_tools();
-  args271 = {
+  args272 = {
     request: UpdateResponseRequest$inboundSchema2
   };
   tool$llmResponsesUpdate = {
@@ -138942,9 +139428,9 @@ var init_llmResponsesUpdate2 = __esm(() => {
     description: `Update a response
 
 Update a response's metadata.`,
-    args: args271,
-    tool: async (client, args272, ctx) => {
-      const [result, apiCall] = await llmResponsesUpdate(client, args272.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args272,
+    tool: async (client, args273, ctx) => {
+      const [result, apiCall] = await llmResponsesUpdate(client, args273.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -138959,9 +139445,9 @@ Update a response's metadata.`,
 
 // src/funcs/llmResponsesWake.ts
 function llmResponsesWake(client, request, options) {
-  return new APIPromise($do280(client, request, options));
+  return new APIPromise($do281(client, request, options));
 }
-async function $do280(client, request, options) {
+async function $do281(client, request, options) {
   const parsed = safeParse4(request, (value) => WakeResponseRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139045,12 +139531,12 @@ var init_llmResponsesWake = __esm(() => {
 });
 
 // src/mcp-server/tools/llmResponsesWake.ts
-var args272, tool$llmResponsesWake;
+var args273, tool$llmResponsesWake;
 var init_llmResponsesWake2 = __esm(() => {
   init_llmResponsesWake();
   init_operations();
   init_tools();
-  args272 = {
+  args273 = {
     request: WakeResponseRequest$inboundSchema
   };
   tool$llmResponsesWake = {
@@ -139058,9 +139544,9 @@ var init_llmResponsesWake2 = __esm(() => {
     description: `Wake a sleeping background response
 
 Interrupts a short sleep tool call on an in-progress background response by providing follow-up input. Wake delivery is polled by the sleeping agent and may take up to one second.`,
-    args: args272,
-    tool: async (client, args273, ctx) => {
-      const [result, apiCall] = await llmResponsesWake(client, args273.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args273,
+    tool: async (client, args274, ctx) => {
+      const [result, apiCall] = await llmResponsesWake(client, args274.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139075,9 +139561,9 @@ Interrupts a short sleep tool call on an in-progress background response by prov
 
 // src/funcs/llmSkillsContent.ts
 function llmSkillsContent(client, request, options) {
-  return new APIPromise($do281(client, request, options));
+  return new APIPromise($do282(client, request, options));
 }
-async function $do281(client, request, options) {
+async function $do282(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139163,12 +139649,12 @@ var init_llmSkillsContent = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsContent.ts
-var args273, tool$llmSkillsContent;
+var args274, tool$llmSkillsContent;
 var init_llmSkillsContent2 = __esm(() => {
   init_llmSkillsContent();
   init_operations();
   init_tools();
-  args273 = {
+  args274 = {
     request: GetSkillContentRequest$inboundSchema
   };
   tool$llmSkillsContent = {
@@ -139176,9 +139662,9 @@ var init_llmSkillsContent2 = __esm(() => {
     description: `Download skill content
 
 Download the zip bundle for a skill's default version.`,
-    args: args273,
-    tool: async (client, args274, ctx) => {
-      const [result, apiCall] = await llmSkillsContent(client, args274.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args274,
+    tool: async (client, args275, ctx) => {
+      const [result, apiCall] = await llmSkillsContent(client, args275.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139193,9 +139679,9 @@ Download the zip bundle for a skill's default version.`,
 
 // src/funcs/llmSkillsCreate.ts
 function llmSkillsCreate(client, request, options) {
-  return new APIPromise($do282(client, request, options));
+  return new APIPromise($do283(client, request, options));
 }
-async function $do282(client, request, options) {
+async function $do283(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139291,12 +139777,12 @@ var init_llmSkillsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsCreate.ts
-var args274, tool$llmSkillsCreate;
+var args275, tool$llmSkillsCreate;
 var init_llmSkillsCreate2 = __esm(() => {
   init_llmSkillsCreate();
   init_operations();
   init_tools();
-  args274 = {
+  args275 = {
     request: CreateSkillRequest$inboundSchema
   };
   tool$llmSkillsCreate = {
@@ -139304,9 +139790,9 @@ var init_llmSkillsCreate2 = __esm(() => {
     description: `Create skill
 
 Create a new skill by uploading files. The uploaded files must include a SKILL.md manifest. Accepts multipart form data with individual files or a single zip archive.`,
-    args: args274,
-    tool: async (client, args275, ctx) => {
-      const [result, apiCall] = await llmSkillsCreate(client, args275.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args275,
+    tool: async (client, args276, ctx) => {
+      const [result, apiCall] = await llmSkillsCreate(client, args276.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139321,9 +139807,9 @@ Create a new skill by uploading files. The uploaded files must include a SKILL.m
 
 // src/funcs/llmSkillsCreateVersion.ts
 function llmSkillsCreateVersion(client, request, options) {
-  return new APIPromise($do283(client, request, options));
+  return new APIPromise($do284(client, request, options));
 }
-async function $do283(client, request, options) {
+async function $do284(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSkillVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139428,12 +139914,12 @@ var init_llmSkillsCreateVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsCreateVersion.ts
-var args275, tool$llmSkillsCreateVersion;
+var args276, tool$llmSkillsCreateVersion;
 var init_llmSkillsCreateVersion2 = __esm(() => {
   init_llmSkillsCreateVersion();
   init_operations();
   init_tools();
-  args275 = {
+  args276 = {
     request: CreateSkillVersionRequest$inboundSchema
   };
   tool$llmSkillsCreateVersion = {
@@ -139441,9 +139927,9 @@ var init_llmSkillsCreateVersion2 = __esm(() => {
     description: `Create skill version
 
 Create a new immutable version of a skill by uploading files. The uploaded files must include a SKILL.md manifest.`,
-    args: args275,
-    tool: async (client, args276, ctx) => {
-      const [result, apiCall] = await llmSkillsCreateVersion(client, args276.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args276,
+    tool: async (client, args277, ctx) => {
+      const [result, apiCall] = await llmSkillsCreateVersion(client, args277.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139458,9 +139944,9 @@ Create a new immutable version of a skill by uploading files. The uploaded files
 
 // src/funcs/llmSkillsDelete.ts
 function llmSkillsDelete(client, request, options) {
-  return new APIPromise($do284(client, request, options));
+  return new APIPromise($do285(client, request, options));
 }
-async function $do284(client, request, options) {
+async function $do285(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139544,12 +140030,12 @@ var init_llmSkillsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsDelete.ts
-var args276, tool$llmSkillsDelete;
+var args277, tool$llmSkillsDelete;
 var init_llmSkillsDelete2 = __esm(() => {
   init_llmSkillsDelete();
   init_operations();
   init_tools();
-  args276 = {
+  args277 = {
     request: DeleteSkillRequest$inboundSchema
   };
   tool$llmSkillsDelete = {
@@ -139557,9 +140043,9 @@ var init_llmSkillsDelete2 = __esm(() => {
     description: `Delete skill
 
 Delete a skill and all its versions.`,
-    args: args276,
-    tool: async (client, args277, ctx) => {
-      const [result, apiCall] = await llmSkillsDelete(client, args277.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args277,
+    tool: async (client, args278, ctx) => {
+      const [result, apiCall] = await llmSkillsDelete(client, args278.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139574,9 +140060,9 @@ Delete a skill and all its versions.`,
 
 // src/funcs/llmSkillsDeleteVersion.ts
 function llmSkillsDeleteVersion(client, request, options) {
-  return new APIPromise($do285(client, request, options));
+  return new APIPromise($do286(client, request, options));
 }
-async function $do285(client, request, options) {
+async function $do286(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSkillVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139664,12 +140150,12 @@ var init_llmSkillsDeleteVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsDeleteVersion.ts
-var args277, tool$llmSkillsDeleteVersion;
+var args278, tool$llmSkillsDeleteVersion;
 var init_llmSkillsDeleteVersion2 = __esm(() => {
   init_llmSkillsDeleteVersion();
   init_operations();
   init_tools();
-  args277 = {
+  args278 = {
     request: DeleteSkillVersionRequest$inboundSchema
   };
   tool$llmSkillsDeleteVersion = {
@@ -139677,9 +140163,9 @@ var init_llmSkillsDeleteVersion2 = __esm(() => {
     description: `Delete skill version
 
 Delete a specific version of a skill.`,
-    args: args277,
-    tool: async (client, args278, ctx) => {
-      const [result, apiCall] = await llmSkillsDeleteVersion(client, args278.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args278,
+    tool: async (client, args279, ctx) => {
+      const [result, apiCall] = await llmSkillsDeleteVersion(client, args279.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139694,9 +140180,9 @@ Delete a specific version of a skill.`,
 
 // src/funcs/llmSkillsGet.ts
 function llmSkillsGet(client, request, options) {
-  return new APIPromise($do286(client, request, options));
+  return new APIPromise($do287(client, request, options));
 }
-async function $do286(client, request, options) {
+async function $do287(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139780,12 +140266,12 @@ var init_llmSkillsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsGet.ts
-var args278, tool$llmSkillsGet;
+var args279, tool$llmSkillsGet;
 var init_llmSkillsGet2 = __esm(() => {
   init_llmSkillsGet();
   init_operations();
   init_tools();
-  args278 = {
+  args279 = {
     request: GetSkillRequest$inboundSchema
   };
   tool$llmSkillsGet = {
@@ -139793,9 +140279,9 @@ var init_llmSkillsGet2 = __esm(() => {
     description: `Retrieve skill
 
 Returns information about a specific skill.`,
-    args: args278,
-    tool: async (client, args279, ctx) => {
-      const [result, apiCall] = await llmSkillsGet(client, args279.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args279,
+    tool: async (client, args280, ctx) => {
+      const [result, apiCall] = await llmSkillsGet(client, args280.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139810,9 +140296,9 @@ Returns information about a specific skill.`,
 
 // src/funcs/llmSkillsGetVersion.ts
 function llmSkillsGetVersion(client, request, options) {
-  return new APIPromise($do287(client, request, options));
+  return new APIPromise($do288(client, request, options));
 }
-async function $do287(client, request, options) {
+async function $do288(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -139900,12 +140386,12 @@ var init_llmSkillsGetVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsGetVersion.ts
-var args279, tool$llmSkillsGetVersion;
+var args280, tool$llmSkillsGetVersion;
 var init_llmSkillsGetVersion2 = __esm(() => {
   init_llmSkillsGetVersion();
   init_operations();
   init_tools();
-  args279 = {
+  args280 = {
     request: GetSkillVersionRequest$inboundSchema
   };
   tool$llmSkillsGetVersion = {
@@ -139913,9 +140399,9 @@ var init_llmSkillsGetVersion2 = __esm(() => {
     description: `Retrieve skill version
 
 Returns information about a specific skill version.`,
-    args: args279,
-    tool: async (client, args280, ctx) => {
-      const [result, apiCall] = await llmSkillsGetVersion(client, args280.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args280,
+    tool: async (client, args281, ctx) => {
+      const [result, apiCall] = await llmSkillsGetVersion(client, args281.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -139930,9 +140416,9 @@ Returns information about a specific skill version.`,
 
 // src/funcs/llmSkillsList.ts
 function llmSkillsList(client, request, options) {
-  return new APIPromise($do288(client, request, options));
+  return new APIPromise($do289(client, request, options));
 }
-async function $do288(client, request, options) {
+async function $do289(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSkillsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140016,12 +140502,12 @@ var init_llmSkillsList = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsList.ts
-var args280, tool$llmSkillsList;
+var args281, tool$llmSkillsList;
 var init_llmSkillsList2 = __esm(() => {
   init_llmSkillsList();
   init_operations();
   init_tools();
-  args280 = {
+  args281 = {
     request: ListSkillsRequest$inboundSchema
   };
   tool$llmSkillsList = {
@@ -140029,9 +140515,9 @@ var init_llmSkillsList2 = __esm(() => {
     description: `List skills
 
 Returns a paginated list of skills.`,
-    args: args280,
-    tool: async (client, args281, ctx) => {
-      const [result, apiCall] = await llmSkillsList(client, args281.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args281,
+    tool: async (client, args282, ctx) => {
+      const [result, apiCall] = await llmSkillsList(client, args282.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140046,9 +140532,9 @@ Returns a paginated list of skills.`,
 
 // src/funcs/llmSkillsListPreconfigured.ts
 function llmSkillsListPreconfigured(client, request, options) {
-  return new APIPromise($do289(client, request, options));
+  return new APIPromise($do290(client, request, options));
 }
-async function $do289(client, request, options) {
+async function $do290(client, request, options) {
   const parsed = safeParse4(request, (value) => ListPreconfiguredSkillsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140126,12 +140612,12 @@ var init_llmSkillsListPreconfigured = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsListPreconfigured.ts
-var args281, tool$llmSkillsListPreconfigured;
+var args282, tool$llmSkillsListPreconfigured;
 var init_llmSkillsListPreconfigured2 = __esm(() => {
   init_llmSkillsListPreconfigured();
   init_operations();
   init_tools();
-  args281 = {
+  args282 = {
     request: ListPreconfiguredSkillsRequest$inboundSchema
   };
   tool$llmSkillsListPreconfigured = {
@@ -140139,9 +140625,9 @@ var init_llmSkillsListPreconfigured2 = __esm(() => {
     description: `List preconfigured skills
 
 Returns the list of preconfigured skills that ship with the gateway. These can be referenced in shell tool definitions as { type: 'preconfigured', name: '...' }.`,
-    args: args281,
-    tool: async (client, args282, ctx) => {
-      const [result, apiCall] = await llmSkillsListPreconfigured(client, args282.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args282,
+    tool: async (client, args283, ctx) => {
+      const [result, apiCall] = await llmSkillsListPreconfigured(client, args283.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140156,9 +140642,9 @@ Returns the list of preconfigured skills that ship with the gateway. These can b
 
 // src/funcs/llmSkillsListVersions.ts
 function llmSkillsListVersions(client, request, options) {
-  return new APIPromise($do290(client, request, options));
+  return new APIPromise($do291(client, request, options));
 }
-async function $do290(client, request, options) {
+async function $do291(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSkillVersionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140248,12 +140734,12 @@ var init_llmSkillsListVersions = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsListVersions.ts
-var args282, tool$llmSkillsListVersions;
+var args283, tool$llmSkillsListVersions;
 var init_llmSkillsListVersions2 = __esm(() => {
   init_llmSkillsListVersions();
   init_operations();
   init_tools();
-  args282 = {
+  args283 = {
     request: ListSkillVersionsRequest$inboundSchema
   };
   tool$llmSkillsListVersions = {
@@ -140261,9 +140747,9 @@ var init_llmSkillsListVersions2 = __esm(() => {
     description: `List skill versions
 
 Returns a paginated list of versions for a skill.`,
-    args: args282,
-    tool: async (client, args283, ctx) => {
-      const [result, apiCall] = await llmSkillsListVersions(client, args283.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args283,
+    tool: async (client, args284, ctx) => {
+      const [result, apiCall] = await llmSkillsListVersions(client, args284.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140278,9 +140764,9 @@ Returns a paginated list of versions for a skill.`,
 
 // src/funcs/llmSkillsUpdate.ts
 function llmSkillsUpdate(client, request, options) {
-  return new APIPromise($do291(client, request, options));
+  return new APIPromise($do292(client, request, options));
 }
-async function $do291(client, request, options) {
+async function $do292(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateSkillRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140367,12 +140853,12 @@ var init_llmSkillsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsUpdate.ts
-var args283, tool$llmSkillsUpdate;
+var args284, tool$llmSkillsUpdate;
 var init_llmSkillsUpdate2 = __esm(() => {
   init_llmSkillsUpdate();
   init_operations();
   init_tools();
-  args283 = {
+  args284 = {
     request: UpdateSkillRequest$inboundSchema
   };
   tool$llmSkillsUpdate = {
@@ -140380,9 +140866,9 @@ var init_llmSkillsUpdate2 = __esm(() => {
     description: `Update skill
 
 Update the default version pointer for a skill.`,
-    args: args283,
-    tool: async (client, args284, ctx) => {
-      const [result, apiCall] = await llmSkillsUpdate(client, args284.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args284,
+    tool: async (client, args285, ctx) => {
+      const [result, apiCall] = await llmSkillsUpdate(client, args285.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140397,9 +140883,9 @@ Update the default version pointer for a skill.`,
 
 // src/funcs/llmSkillsVersionContent.ts
 function llmSkillsVersionContent(client, request, options) {
-  return new APIPromise($do292(client, request, options));
+  return new APIPromise($do293(client, request, options));
 }
-async function $do292(client, request, options) {
+async function $do293(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSkillVersionContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140489,12 +140975,12 @@ var init_llmSkillsVersionContent = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSkillsVersionContent.ts
-var args284, tool$llmSkillsVersionContent;
+var args285, tool$llmSkillsVersionContent;
 var init_llmSkillsVersionContent2 = __esm(() => {
   init_llmSkillsVersionContent();
   init_operations();
   init_tools();
-  args284 = {
+  args285 = {
     request: GetSkillVersionContentRequest$inboundSchema
   };
   tool$llmSkillsVersionContent = {
@@ -140502,9 +140988,9 @@ var init_llmSkillsVersionContent2 = __esm(() => {
     description: `Download skill version content
 
 Download the zip bundle for a specific skill version.`,
-    args: args284,
-    tool: async (client, args285, ctx) => {
-      const [result, apiCall] = await llmSkillsVersionContent(client, args285.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args285,
+    tool: async (client, args286, ctx) => {
+      const [result, apiCall] = await llmSkillsVersionContent(client, args286.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140519,9 +141005,9 @@ Download the zip bundle for a specific skill version.`,
 
 // src/funcs/llmSpeechDeleteTranscriptionHistory.ts
 function llmSpeechDeleteTranscriptionHistory(client, request, options) {
-  return new APIPromise($do293(client, request, options));
+  return new APIPromise($do294(client, request, options));
 }
-async function $do293(client, request, options) {
+async function $do294(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteSpeechToTextHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140605,12 +141091,12 @@ var init_llmSpeechDeleteTranscriptionHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechDeleteTranscriptionHistory.ts
-var args285, tool$llmSpeechDeleteTranscriptionHistory;
+var args286, tool$llmSpeechDeleteTranscriptionHistory;
 var init_llmSpeechDeleteTranscriptionHistory2 = __esm(() => {
   init_llmSpeechDeleteTranscriptionHistory();
   init_operations();
   init_tools();
-  args285 = {
+  args286 = {
     request: DeleteSpeechToTextHistoryRequest$inboundSchema
   };
   tool$llmSpeechDeleteTranscriptionHistory = {
@@ -140618,9 +141104,9 @@ var init_llmSpeechDeleteTranscriptionHistory2 = __esm(() => {
     description: `Delete speech-to-text history item
 
 Deletes a stored transcription. The audio blob is content-addressed and may be shared, so it is left in storage.`,
-    args: args285,
-    tool: async (client, args286, ctx) => {
-      const [result, apiCall] = await llmSpeechDeleteTranscriptionHistory(client, args286.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args286,
+    tool: async (client, args287, ctx) => {
+      const [result, apiCall] = await llmSpeechDeleteTranscriptionHistory(client, args287.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140635,9 +141121,9 @@ Deletes a stored transcription. The audio blob is content-addressed and may be s
 
 // src/funcs/llmSpeechDeleteTtsHistory.ts
 function llmSpeechDeleteTtsHistory(client, request, options) {
-  return new APIPromise($do294(client, request, options));
+  return new APIPromise($do295(client, request, options));
 }
-async function $do294(client, request, options) {
+async function $do295(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteTextToSpeechHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140721,12 +141207,12 @@ var init_llmSpeechDeleteTtsHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechDeleteTtsHistory.ts
-var args286, tool$llmSpeechDeleteTtsHistory;
+var args287, tool$llmSpeechDeleteTtsHistory;
 var init_llmSpeechDeleteTtsHistory2 = __esm(() => {
   init_llmSpeechDeleteTtsHistory();
   init_operations();
   init_tools();
-  args286 = {
+  args287 = {
     request: DeleteTextToSpeechHistoryRequest$inboundSchema
   };
   tool$llmSpeechDeleteTtsHistory = {
@@ -140734,9 +141220,9 @@ var init_llmSpeechDeleteTtsHistory2 = __esm(() => {
     description: `Delete text-to-speech history item
 
 Deletes a stored text-to-speech generation. The audio blob is content-addressed and may be shared, so it is left in storage.`,
-    args: args286,
-    tool: async (client, args287, ctx) => {
-      const [result, apiCall] = await llmSpeechDeleteTtsHistory(client, args287.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args287,
+    tool: async (client, args288, ctx) => {
+      const [result, apiCall] = await llmSpeechDeleteTtsHistory(client, args288.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140751,9 +141237,9 @@ Deletes a stored text-to-speech generation. The audio blob is content-addressed
 
 // src/funcs/llmSpeechGetTranscriptionHistory.ts
 function llmSpeechGetTranscriptionHistory(client, request, options) {
-  return new APIPromise($do295(client, request, options));
+  return new APIPromise($do296(client, request, options));
 }
-async function $do295(client, request, options) {
+async function $do296(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSpeechToTextHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140837,12 +141323,12 @@ var init_llmSpeechGetTranscriptionHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechGetTranscriptionHistory.ts
-var args287, tool$llmSpeechGetTranscriptionHistory;
+var args288, tool$llmSpeechGetTranscriptionHistory;
 var init_llmSpeechGetTranscriptionHistory2 = __esm(() => {
   init_llmSpeechGetTranscriptionHistory();
   init_operations();
   init_tools();
-  args287 = {
+  args288 = {
     request: GetSpeechToTextHistoryRequest$inboundSchema
   };
   tool$llmSpeechGetTranscriptionHistory = {
@@ -140850,9 +141336,9 @@ var init_llmSpeechGetTranscriptionHistory2 = __esm(() => {
     description: `Retrieve speech-to-text history item
 
 Returns metadata for a stored transcription.`,
-    args: args287,
-    tool: async (client, args288, ctx) => {
-      const [result, apiCall] = await llmSpeechGetTranscriptionHistory(client, args288.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args288,
+    tool: async (client, args289, ctx) => {
+      const [result, apiCall] = await llmSpeechGetTranscriptionHistory(client, args289.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140867,9 +141353,9 @@ Returns metadata for a stored transcription.`,
 
 // src/funcs/llmSpeechGetTranscriptionHistoryContent.ts
 function llmSpeechGetTranscriptionHistoryContent(client, request, options) {
-  return new APIPromise($do296(client, request, options));
+  return new APIPromise($do297(client, request, options));
 }
-async function $do296(client, request, options) {
+async function $do297(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSpeechToTextHistoryContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -140953,12 +141439,12 @@ var init_llmSpeechGetTranscriptionHistoryContent = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechGetTranscriptionHistoryContent.ts
-var args288, tool$llmSpeechGetTranscriptionHistoryContent;
+var args289, tool$llmSpeechGetTranscriptionHistoryContent;
 var init_llmSpeechGetTranscriptionHistoryContent2 = __esm(() => {
   init_llmSpeechGetTranscriptionHistoryContent();
   init_operations();
   init_tools();
-  args288 = {
+  args289 = {
     request: GetSpeechToTextHistoryContentRequest$inboundSchema
   };
   tool$llmSpeechGetTranscriptionHistoryContent = {
@@ -140966,9 +141452,9 @@ var init_llmSpeechGetTranscriptionHistoryContent2 = __esm(() => {
     description: `Retrieve speech-to-text audio
 
 Returns the stored input audio for a transcription as a binary response.`,
-    args: args288,
-    tool: async (client, args289, ctx) => {
-      const [result, apiCall] = await llmSpeechGetTranscriptionHistoryContent(client, args289.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args289,
+    tool: async (client, args290, ctx) => {
+      const [result, apiCall] = await llmSpeechGetTranscriptionHistoryContent(client, args290.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -140983,9 +141469,9 @@ Returns the stored input audio for a transcription as a binary response.`,
 
 // src/funcs/llmSpeechGetTtsHistory.ts
 function llmSpeechGetTtsHistory(client, request, options) {
-  return new APIPromise($do297(client, request, options));
+  return new APIPromise($do298(client, request, options));
 }
-async function $do297(client, request, options) {
+async function $do298(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTextToSpeechHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141069,12 +141555,12 @@ var init_llmSpeechGetTtsHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechGetTtsHistory.ts
-var args289, tool$llmSpeechGetTtsHistory;
+var args290, tool$llmSpeechGetTtsHistory;
 var init_llmSpeechGetTtsHistory2 = __esm(() => {
   init_llmSpeechGetTtsHistory();
   init_operations();
   init_tools();
-  args289 = {
+  args290 = {
     request: GetTextToSpeechHistoryRequest$inboundSchema
   };
   tool$llmSpeechGetTtsHistory = {
@@ -141082,9 +141568,9 @@ var init_llmSpeechGetTtsHistory2 = __esm(() => {
     description: `Retrieve text-to-speech history item
 
 Returns metadata for a stored text-to-speech generation.`,
-    args: args289,
-    tool: async (client, args290, ctx) => {
-      const [result, apiCall] = await llmSpeechGetTtsHistory(client, args290.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args290,
+    tool: async (client, args291, ctx) => {
+      const [result, apiCall] = await llmSpeechGetTtsHistory(client, args291.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141099,9 +141585,9 @@ Returns metadata for a stored text-to-speech generation.`,
 
 // src/funcs/llmSpeechGetTtsHistoryContent.ts
 function llmSpeechGetTtsHistoryContent(client, request, options) {
-  return new APIPromise($do298(client, request, options));
+  return new APIPromise($do299(client, request, options));
 }
-async function $do298(client, request, options) {
+async function $do299(client, request, options) {
   const parsed = safeParse4(request, (value) => GetTextToSpeechHistoryContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141184,12 +141670,12 @@ var init_llmSpeechGetTtsHistoryContent = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechGetTtsHistoryContent.ts
-var args290, tool$llmSpeechGetTtsHistoryContent;
+var args291, tool$llmSpeechGetTtsHistoryContent;
 var init_llmSpeechGetTtsHistoryContent2 = __esm(() => {
   init_llmSpeechGetTtsHistoryContent();
   init_operations();
   init_tools();
-  args290 = {
+  args291 = {
     request: GetTextToSpeechHistoryContentRequest$inboundSchema
   };
   tool$llmSpeechGetTtsHistoryContent = {
@@ -141197,9 +141683,9 @@ var init_llmSpeechGetTtsHistoryContent2 = __esm(() => {
     description: `Retrieve text-to-speech audio
 
 Returns the stored audio for a text-to-speech generation as a binary response.`,
-    args: args290,
-    tool: async (client, args291, ctx) => {
-      const [result, apiCall] = await llmSpeechGetTtsHistoryContent(client, args291.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args291,
+    tool: async (client, args292, ctx) => {
+      const [result, apiCall] = await llmSpeechGetTtsHistoryContent(client, args292.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141214,9 +141700,9 @@ Returns the stored audio for a text-to-speech generation as a binary response.`,
 
 // src/funcs/llmSpeechListTranscriptionHistory.ts
 function llmSpeechListTranscriptionHistory(client, request, options) {
-  return new APIPromise($do299(client, request, options));
+  return new APIPromise($do300(client, request, options));
 }
-async function $do299(client, request, options) {
+async function $do300(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSpeechToTextHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141301,12 +141787,12 @@ var init_llmSpeechListTranscriptionHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechListTranscriptionHistory.ts
-var args291, tool$llmSpeechListTranscriptionHistory;
+var args292, tool$llmSpeechListTranscriptionHistory;
 var init_llmSpeechListTranscriptionHistory2 = __esm(() => {
   init_llmSpeechListTranscriptionHistory();
   init_operations();
   init_tools();
-  args291 = {
+  args292 = {
     request: ListSpeechToTextHistoryRequest$inboundSchema
   };
   tool$llmSpeechListTranscriptionHistory = {
@@ -141314,9 +141800,9 @@ var init_llmSpeechListTranscriptionHistory2 = __esm(() => {
     description: `List speech-to-text history
 
 List stored transcriptions for the authenticated user, newest first by default.`,
-    args: args291,
-    tool: async (client, args292, ctx) => {
-      const [result, apiCall] = await llmSpeechListTranscriptionHistory(client, args292.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args292,
+    tool: async (client, args293, ctx) => {
+      const [result, apiCall] = await llmSpeechListTranscriptionHistory(client, args293.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141331,9 +141817,9 @@ List stored transcriptions for the authenticated user, newest first by default.`
 
 // src/funcs/llmSpeechListTtsHistory.ts
 function llmSpeechListTtsHistory(client, request, options) {
-  return new APIPromise($do300(client, request, options));
+  return new APIPromise($do301(client, request, options));
 }
-async function $do300(client, request, options) {
+async function $do301(client, request, options) {
   const parsed = safeParse4(request, (value) => ListTextToSpeechHistoryRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141418,12 +141904,12 @@ var init_llmSpeechListTtsHistory = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechListTtsHistory.ts
-var args292, tool$llmSpeechListTtsHistory;
+var args293, tool$llmSpeechListTtsHistory;
 var init_llmSpeechListTtsHistory2 = __esm(() => {
   init_llmSpeechListTtsHistory();
   init_operations();
   init_tools();
-  args292 = {
+  args293 = {
     request: ListTextToSpeechHistoryRequest$inboundSchema
   };
   tool$llmSpeechListTtsHistory = {
@@ -141431,9 +141917,9 @@ var init_llmSpeechListTtsHistory2 = __esm(() => {
     description: `List text-to-speech history
 
 List stored text-to-speech generations for the authenticated user, newest first by default.`,
-    args: args292,
-    tool: async (client, args293, ctx) => {
-      const [result, apiCall] = await llmSpeechListTtsHistory(client, args293.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args293,
+    tool: async (client, args294, ctx) => {
+      const [result, apiCall] = await llmSpeechListTtsHistory(client, args294.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141448,9 +141934,9 @@ List stored text-to-speech generations for the authenticated user, newest first
 
 // src/funcs/llmSpeechLivekitToken.ts
 function llmSpeechLivekitToken(client, request, options) {
-  return new APIPromise($do301(client, request, options));
+  return new APIPromise($do302(client, request, options));
 }
-async function $do301(client, request, options) {
+async function $do302(client, request, options) {
   const parsed = safeParse4(request, (value) => LivekitTokenRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141531,12 +142017,12 @@ var init_llmSpeechLivekitToken = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechLivekitToken.ts
-var args293, tool$llmSpeechLivekitToken;
+var args294, tool$llmSpeechLivekitToken;
 var init_llmSpeechLivekitToken2 = __esm(() => {
   init_llmSpeechLivekitToken();
   init_operations();
   init_tools();
-  args293 = {
+  args294 = {
     request: LivekitTokenRequest$inboundSchema2
   };
   tool$llmSpeechLivekitToken = {
@@ -141544,9 +142030,9 @@ var init_llmSpeechLivekitToken2 = __esm(() => {
     description: `Generate LiveKit room token
 
 Generates a LiveKit access token for joining a real-time voice room. The token includes encrypted credentials and model configuration for the voice agent.`,
-    args: args293,
-    tool: async (client, args294, ctx) => {
-      const [result, apiCall] = await llmSpeechLivekitToken(client, args294.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args294,
+    tool: async (client, args295, ctx) => {
+      const [result, apiCall] = await llmSpeechLivekitToken(client, args295.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141561,9 +142047,9 @@ Generates a LiveKit access token for joining a real-time voice room. The token i
 
 // src/funcs/llmSpeechSpeak.ts
 function llmSpeechSpeak(client, request, options) {
-  return new APIPromise($do302(client, request, options));
+  return new APIPromise($do303(client, request, options));
 }
-async function $do302(client, request, options) {
+async function $do303(client, request, options) {
   const parsed = safeParse4(request, (value) => TextToSpeechRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141650,12 +142136,12 @@ var init_llmSpeechSpeak = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechSpeak.ts
-var args294, tool$llmSpeechSpeak;
+var args295, tool$llmSpeechSpeak;
 var init_llmSpeechSpeak2 = __esm(() => {
   init_llmSpeechSpeak();
   init_operations();
   init_tools();
-  args294 = {
+  args295 = {
     request: TextToSpeechRequest$inboundSchema2
   };
   tool$llmSpeechSpeak = {
@@ -141670,9 +142156,9 @@ Convert text to speech with automatic language detection.
 - \`model\`: TTS model identifier (default: "auto") - "auto" selects the default provider; a registry-resolvable id dispatches to the matching provider
 
 **Response:** Returns audio file in WAV format with X-Language-Code header. When \`store\` is \`true\`, the generation is persisted before the response returns and the new history record id is included in the X-Tts-Id header.`,
-    args: args294,
-    tool: async (client, args295, ctx) => {
-      const [result, apiCall] = await llmSpeechSpeak(client, args295.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args295,
+    tool: async (client, args296, ctx) => {
+      const [result, apiCall] = await llmSpeechSpeak(client, args296.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141687,9 +142173,9 @@ Convert text to speech with automatic language detection.
 
 // src/funcs/llmSpeechSpeakStreaming.ts
 function llmSpeechSpeakStreaming(client, request, options) {
-  return new APIPromise($do303(client, request, options));
+  return new APIPromise($do304(client, request, options));
 }
-async function $do303(client, request, options) {
+async function $do304(client, request, options) {
   const parsed = safeParse4(request, (value) => TextToSpeechStreamingRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141780,12 +142266,12 @@ var init_llmSpeechSpeakStreaming = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechSpeakStreaming.ts
-var args295, tool$llmSpeechSpeakStreaming;
+var args296, tool$llmSpeechSpeakStreaming;
 var init_llmSpeechSpeakStreaming2 = __esm(() => {
   init_llmSpeechSpeakStreaming();
   init_operations();
   init_tools();
-  args295 = {
+  args296 = {
     request: TextToSpeechStreamingRequest$inboundSchema2
   };
   tool$llmSpeechSpeakStreaming = {
@@ -141816,9 +142302,9 @@ Convert text to speech with real-time streaming audio delivery.
 - Real-time applications requiring immediate audio playback
 - Interactive voice responses
 - Low-latency text-to-speech scenarios`,
-    args: args295,
-    tool: async (client, args296, ctx) => {
-      const [result, apiCall] = await llmSpeechSpeakStreaming(client, args296.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args296,
+    tool: async (client, args297, ctx) => {
+      const [result, apiCall] = await llmSpeechSpeakStreaming(client, args297.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141833,9 +142319,9 @@ Convert text to speech with real-time streaming audio delivery.
 
 // src/funcs/llmSpeechTranscribe.ts
 function llmSpeechTranscribe(client, request, options) {
-  return new APIPromise($do304(client, request, options));
+  return new APIPromise($do305(client, request, options));
 }
-async function $do304(client, request, options) {
+async function $do305(client, request, options) {
   const parsed = safeParse4(request, (value) => TranscribeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -141936,12 +142422,12 @@ var init_llmSpeechTranscribe = __esm(() => {
 });
 
 // src/mcp-server/tools/llmSpeechTranscribe.ts
-var args296, tool$llmSpeechTranscribe;
+var args297, tool$llmSpeechTranscribe;
 var init_llmSpeechTranscribe2 = __esm(() => {
   init_llmSpeechTranscribe();
   init_operations();
   init_tools();
-  args296 = {
+  args297 = {
     request: TranscribeRequest$inboundSchema
   };
   tool$llmSpeechTranscribe = {
@@ -141976,9 +142462,9 @@ curl -X POST "http://localhost:3000/api/v1/llm/speech/transcriptions?language=en
 - \`include_speaker_data\` (optional): When \`true\`, include speaker diarization data and require WAV/PCM input. Otherwise transcription uses the standard compatibility path.
 
 **Response:** Returns transcribed text in JSON format.`,
-    args: args296,
-    tool: async (client, args297, ctx) => {
-      const [result, apiCall] = await llmSpeechTranscribe(client, args297.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args297,
+    tool: async (client, args298, ctx) => {
+      const [result, apiCall] = await llmSpeechTranscribe(client, args298.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -141993,9 +142479,9 @@ curl -X POST "http://localhost:3000/api/v1/llm/speech/transcriptions?language=en
 
 // src/funcs/llmUsageClassify.ts
 function llmUsageClassify(client, request, options) {
-  return new APIPromise($do305(client, request, options));
+  return new APIPromise($do306(client, request, options));
 }
-async function $do305(client, request, options) {
+async function $do306(client, request, options) {
   const parsed = safeParse4(request, (value) => GetClassifyUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142086,12 +142572,12 @@ var init_llmUsageClassify = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageClassify.ts
-var args297, tool$llmUsageClassify;
+var args298, tool$llmUsageClassify;
 var init_llmUsageClassify2 = __esm(() => {
   init_llmUsageClassify();
   init_operations();
   init_tools();
-  args297 = {
+  args298 = {
     request: GetClassifyUsageRequest$inboundSchema
   };
   tool$llmUsageClassify = {
@@ -142099,9 +142585,9 @@ var init_llmUsageClassify2 = __esm(() => {
     description: `Get classify usage
 
 Retrieve usage metrics for classify operations.`,
-    args: args297,
-    tool: async (client, args298, ctx) => {
-      const [result, apiCall] = await llmUsageClassify(client, args298.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args298,
+    tool: async (client, args299, ctx) => {
+      const [result, apiCall] = await llmUsageClassify(client, args299.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142116,9 +142602,9 @@ Retrieve usage metrics for classify operations.`,
 
 // src/funcs/llmUsageCompletions.ts
 function llmUsageCompletions(client, request, options) {
-  return new APIPromise($do306(client, request, options));
+  return new APIPromise($do307(client, request, options));
 }
-async function $do306(client, request, options) {
+async function $do307(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCompletionsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142209,12 +142695,12 @@ var init_llmUsageCompletions = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageCompletions.ts
-var args298, tool$llmUsageCompletions;
+var args299, tool$llmUsageCompletions;
 var init_llmUsageCompletions2 = __esm(() => {
   init_llmUsageCompletions();
   init_operations();
   init_tools();
-  args298 = {
+  args299 = {
     request: GetCompletionsUsageRequest$inboundSchema
   };
   tool$llmUsageCompletions = {
@@ -142222,9 +142708,9 @@ var init_llmUsageCompletions2 = __esm(() => {
     description: `Get completions usage
 
 Retrieve usage metrics for chat completions, aggregated from the ChatCompletion table.`,
-    args: args298,
-    tool: async (client, args299, ctx) => {
-      const [result, apiCall] = await llmUsageCompletions(client, args299.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args299,
+    tool: async (client, args300, ctx) => {
+      const [result, apiCall] = await llmUsageCompletions(client, args300.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142239,9 +142725,9 @@ Retrieve usage metrics for chat completions, aggregated from the ChatCompletion
 
 // src/funcs/llmUsageConversations.ts
 function llmUsageConversations(client, request, options) {
-  return new APIPromise($do307(client, request, options));
+  return new APIPromise($do308(client, request, options));
 }
-async function $do307(client, request, options) {
+async function $do308(client, request, options) {
   const parsed = safeParse4(request, (value) => GetConversationsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142331,12 +142817,12 @@ var init_llmUsageConversations = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageConversations.ts
-var args299, tool$llmUsageConversations;
+var args300, tool$llmUsageConversations;
 var init_llmUsageConversations2 = __esm(() => {
   init_llmUsageConversations();
   init_operations();
   init_tools();
-  args299 = {
+  args300 = {
     request: GetConversationsUsageRequest$inboundSchema
   };
   tool$llmUsageConversations = {
@@ -142344,9 +142830,9 @@ var init_llmUsageConversations2 = __esm(() => {
     description: `Get conversations usage
 
 Retrieve usage metrics for conversation operations.`,
-    args: args299,
-    tool: async (client, args300, ctx) => {
-      const [result, apiCall] = await llmUsageConversations(client, args300.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args300,
+    tool: async (client, args301, ctx) => {
+      const [result, apiCall] = await llmUsageConversations(client, args301.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142361,9 +142847,9 @@ Retrieve usage metrics for conversation operations.`,
 
 // src/funcs/llmUsageCosts.ts
 function llmUsageCosts(client, request, options) {
-  return new APIPromise($do308(client, request, options));
+  return new APIPromise($do309(client, request, options));
 }
-async function $do308(client, request, options) {
+async function $do309(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142448,12 +142934,12 @@ var init_llmUsageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageCosts.ts
-var args300, tool$llmUsageCosts;
+var args301, tool$llmUsageCosts;
 var init_llmUsageCosts2 = __esm(() => {
   init_llmUsageCosts();
   init_operations();
   init_tools();
-  args300 = {
+  args301 = {
     request: GetCostsUsageRequest$inboundSchema
   };
   tool$llmUsageCosts = {
@@ -142461,9 +142947,9 @@ var init_llmUsageCosts2 = __esm(() => {
     description: `Get cost by model
 
 Aggregates spend by model over a time range, priced in the cluster currency from the model price book. Org-scoped: org admins see their org; cluster admins may pass \`org_id\`. Includes billable work with no usage row of its own (store=false responses, agent tool calls), so totals cover all LLM spend. Platform-wide, cross-service cost reporting lives in the budgeting API (/api/v1/budgeting/usage/costs).`,
-    args: args300,
-    tool: async (client, args301, ctx) => {
-      const [result, apiCall] = await llmUsageCosts(client, args301.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args301,
+    tool: async (client, args302, ctx) => {
+      const [result, apiCall] = await llmUsageCosts(client, args302.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142478,9 +142964,9 @@ Aggregates spend by model over a time range, priced in the cluster currency from
 
 // src/funcs/llmUsageEmbeddings.ts
 function llmUsageEmbeddings(client, request, options) {
-  return new APIPromise($do309(client, request, options));
+  return new APIPromise($do310(client, request, options));
 }
-async function $do309(client, request, options) {
+async function $do310(client, request, options) {
   const parsed = safeParse4(request, (value) => GetEmbeddingsUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142571,12 +143057,12 @@ var init_llmUsageEmbeddings = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageEmbeddings.ts
-var args301, tool$llmUsageEmbeddings;
+var args302, tool$llmUsageEmbeddings;
 var init_llmUsageEmbeddings2 = __esm(() => {
   init_llmUsageEmbeddings();
   init_operations();
   init_tools();
-  args301 = {
+  args302 = {
     request: GetEmbeddingsUsageRequest$inboundSchema
   };
   tool$llmUsageEmbeddings = {
@@ -142584,9 +143070,9 @@ var init_llmUsageEmbeddings2 = __esm(() => {
     description: `Get embeddings usage
 
 Retrieve usage metrics for embedding operations.`,
-    args: args301,
-    tool: async (client, args302, ctx) => {
-      const [result, apiCall] = await llmUsageEmbeddings(client, args302.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args302,
+    tool: async (client, args303, ctx) => {
+      const [result, apiCall] = await llmUsageEmbeddings(client, args303.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142601,9 +143087,9 @@ Retrieve usage metrics for embedding operations.`,
 
 // src/funcs/llmUsageExtract.ts
 function llmUsageExtract(client, request, options) {
-  return new APIPromise($do310(client, request, options));
+  return new APIPromise($do311(client, request, options));
 }
-async function $do310(client, request, options) {
+async function $do311(client, request, options) {
   const parsed = safeParse4(request, (value) => GetExtractUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142694,12 +143180,12 @@ var init_llmUsageExtract = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageExtract.ts
-var args302, tool$llmUsageExtract;
+var args303, tool$llmUsageExtract;
 var init_llmUsageExtract2 = __esm(() => {
   init_llmUsageExtract();
   init_operations();
   init_tools();
-  args302 = {
+  args303 = {
     request: GetExtractUsageRequest$inboundSchema
   };
   tool$llmUsageExtract = {
@@ -142707,9 +143193,9 @@ var init_llmUsageExtract2 = __esm(() => {
     description: `Get extract usage
 
 Retrieve usage metrics for extract operations.`,
-    args: args302,
-    tool: async (client, args303, ctx) => {
-      const [result, apiCall] = await llmUsageExtract(client, args303.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args303,
+    tool: async (client, args304, ctx) => {
+      const [result, apiCall] = await llmUsageExtract(client, args304.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142724,9 +143210,9 @@ Retrieve usage metrics for extract operations.`,
 
 // src/funcs/llmUsageFiles.ts
 function llmUsageFiles(client, request, options) {
-  return new APIPromise($do311(client, request, options));
+  return new APIPromise($do312(client, request, options));
 }
-async function $do311(client, request, options) {
+async function $do312(client, request, options) {
   const parsed = safeParse4(request, (value) => GetFilesUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142816,12 +143302,12 @@ var init_llmUsageFiles = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageFiles.ts
-var args303, tool$llmUsageFiles;
+var args304, tool$llmUsageFiles;
 var init_llmUsageFiles2 = __esm(() => {
   init_llmUsageFiles();
   init_operations();
   init_tools();
-  args303 = {
+  args304 = {
     request: GetFilesUsageRequest$inboundSchema
   };
   tool$llmUsageFiles = {
@@ -142829,9 +143315,9 @@ var init_llmUsageFiles2 = __esm(() => {
     description: `Get files usage
 
 Retrieve bytes of files created per period from durable file creation events. This does not reflect current retained storage, buckets remain counted after file deletion, and grouped results collapse by requested output dimensions rather than one row per UserContext.`,
-    args: args303,
-    tool: async (client, args304, ctx) => {
-      const [result, apiCall] = await llmUsageFiles(client, args304.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args304,
+    tool: async (client, args305, ctx) => {
+      const [result, apiCall] = await llmUsageFiles(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142846,9 +143332,9 @@ Retrieve bytes of files created per period from durable file creation events. Th
 
 // src/funcs/llmUsageResponses.ts
 function llmUsageResponses(client, request, options) {
-  return new APIPromise($do312(client, request, options));
+  return new APIPromise($do313(client, request, options));
 }
-async function $do312(client, request, options) {
+async function $do313(client, request, options) {
   const parsed = safeParse4(request, (value) => GetResponsesUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -142940,12 +143426,12 @@ var init_llmUsageResponses = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageResponses.ts
-var args304, tool$llmUsageResponses;
+var args305, tool$llmUsageResponses;
 var init_llmUsageResponses2 = __esm(() => {
   init_llmUsageResponses();
   init_operations();
   init_tools();
-  args304 = {
+  args305 = {
     request: GetResponsesUsageRequest$inboundSchema
   };
   tool$llmUsageResponses = {
@@ -142953,9 +143439,9 @@ var init_llmUsageResponses2 = __esm(() => {
     description: `Get responses usage
 
 Retrieve usage metrics for agent responses, aggregated from the Response table.`,
-    args: args304,
-    tool: async (client, args305, ctx) => {
-      const [result, apiCall] = await llmUsageResponses(client, args305.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args305,
+    tool: async (client, args306, ctx) => {
+      const [result, apiCall] = await llmUsageResponses(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -142970,9 +143456,9 @@ Retrieve usage metrics for agent responses, aggregated from the Response table.`
 
 // src/funcs/llmUsageVectorStores.ts
 function llmUsageVectorStores(client, request, options) {
-  return new APIPromise($do313(client, request, options));
+  return new APIPromise($do314(client, request, options));
 }
-async function $do313(client, request, options) {
+async function $do314(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoresUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143062,12 +143548,12 @@ var init_llmUsageVectorStores = __esm(() => {
 });
 
 // src/mcp-server/tools/llmUsageVectorStores.ts
-var args305, tool$llmUsageVectorStores;
+var args306, tool$llmUsageVectorStores;
 var init_llmUsageVectorStores2 = __esm(() => {
   init_llmUsageVectorStores();
   init_operations();
   init_tools();
-  args305 = {
+  args306 = {
     request: GetVectorStoresUsageRequest$inboundSchema
   };
   tool$llmUsageVectorStores = {
@@ -143075,9 +143561,9 @@ var init_llmUsageVectorStores2 = __esm(() => {
     description: `Get vector stores usage
 
 Retrieve usage metrics for vector storage operations.`,
-    args: args305,
-    tool: async (client, args306, ctx) => {
-      const [result, apiCall] = await llmUsageVectorStores(client, args306.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args306,
+    tool: async (client, args307, ctx) => {
+      const [result, apiCall] = await llmUsageVectorStores(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143092,9 +143578,9 @@ Retrieve usage metrics for vector storage operations.`,
 
 // src/funcs/llmVectorStoresCancelFileBatch.ts
 function llmVectorStoresCancelFileBatch(client, request, options) {
-  return new APIPromise($do314(client, request, options));
+  return new APIPromise($do315(client, request, options));
 }
-async function $do314(client, request, options) {
+async function $do315(client, request, options) {
   const parsed = safeParse4(request, (value) => CancelVectorStoreFileBatchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143182,12 +143668,12 @@ var init_llmVectorStoresCancelFileBatch = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresCancelFileBatch.ts
-var args306, tool$llmVectorStoresCancelFileBatch;
+var args307, tool$llmVectorStoresCancelFileBatch;
 var init_llmVectorStoresCancelFileBatch2 = __esm(() => {
   init_llmVectorStoresCancelFileBatch();
   init_operations();
   init_tools();
-  args306 = {
+  args307 = {
     request: CancelVectorStoreFileBatchRequest$inboundSchema
   };
   tool$llmVectorStoresCancelFileBatch = {
@@ -143195,9 +143681,9 @@ var init_llmVectorStoresCancelFileBatch2 = __esm(() => {
     description: `Cancel batch file processing
 
 Cancels an in-progress file batch operation.`,
-    args: args306,
-    tool: async (client, args307, ctx) => {
-      const [result, apiCall] = await llmVectorStoresCancelFileBatch(client, args307.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args307,
+    tool: async (client, args308, ctx) => {
+      const [result, apiCall] = await llmVectorStoresCancelFileBatch(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143212,9 +143698,9 @@ Cancels an in-progress file batch operation.`,
 
 // src/funcs/llmVectorStoresCreate.ts
 function llmVectorStoresCreate(client, request, options) {
-  return new APIPromise($do315(client, request, options));
+  return new APIPromise($do316(client, request, options));
 }
-async function $do315(client, request, options) {
+async function $do316(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVectorStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143295,12 +143781,12 @@ var init_llmVectorStoresCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresCreate.ts
-var args307, tool$llmVectorStoresCreate;
+var args308, tool$llmVectorStoresCreate;
 var init_llmVectorStoresCreate2 = __esm(() => {
   init_llmVectorStoresCreate();
   init_operations();
   init_tools();
-  args307 = {
+  args308 = {
     request: CreateVectorStoreRequest$inboundSchema2
   };
   tool$llmVectorStoresCreate = {
@@ -143308,9 +143794,9 @@ var init_llmVectorStoresCreate2 = __esm(() => {
     description: `Create a vector store
 
 Creates a new vector store for storing and searching through document embeddings.`,
-    args: args307,
-    tool: async (client, args308, ctx) => {
-      const [result, apiCall] = await llmVectorStoresCreate(client, args308.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args308,
+    tool: async (client, args309, ctx) => {
+      const [result, apiCall] = await llmVectorStoresCreate(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143325,9 +143811,9 @@ Creates a new vector store for storing and searching through document embeddings
 
 // src/funcs/llmVectorStoresCreateFile.ts
 function llmVectorStoresCreateFile(client, request, options) {
-  return new APIPromise($do316(client, request, options));
+  return new APIPromise($do317(client, request, options));
 }
-async function $do316(client, request, options) {
+async function $do317(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVectorStoreFileRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143414,12 +143900,12 @@ var init_llmVectorStoresCreateFile = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresCreateFile.ts
-var args308, tool$llmVectorStoresCreateFile;
+var args309, tool$llmVectorStoresCreateFile;
 var init_llmVectorStoresCreateFile2 = __esm(() => {
   init_llmVectorStoresCreateFile();
   init_operations();
   init_tools();
-  args308 = {
+  args309 = {
     request: CreateVectorStoreFileRequest$inboundSchema2
   };
   tool$llmVectorStoresCreateFile = {
@@ -143427,9 +143913,9 @@ var init_llmVectorStoresCreateFile2 = __esm(() => {
     description: `Add a file to a vector store
 
 Adds a file to a vector store for semantic search indexing.`,
-    args: args308,
-    tool: async (client, args309, ctx) => {
-      const [result, apiCall] = await llmVectorStoresCreateFile(client, args309.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args309,
+    tool: async (client, args310, ctx) => {
+      const [result, apiCall] = await llmVectorStoresCreateFile(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143444,9 +143930,9 @@ Adds a file to a vector store for semantic search indexing.`,
 
 // src/funcs/llmVectorStoresCreateFileBatch.ts
 function llmVectorStoresCreateFileBatch(client, request, options) {
-  return new APIPromise($do317(client, request, options));
+  return new APIPromise($do318(client, request, options));
 }
-async function $do317(client, request, options) {
+async function $do318(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateVectorStoreFileBatchRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143533,12 +144019,12 @@ var init_llmVectorStoresCreateFileBatch = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresCreateFileBatch.ts
-var args309, tool$llmVectorStoresCreateFileBatch;
+var args310, tool$llmVectorStoresCreateFileBatch;
 var init_llmVectorStoresCreateFileBatch2 = __esm(() => {
   init_llmVectorStoresCreateFileBatch();
   init_operations();
   init_tools();
-  args309 = {
+  args310 = {
     request: CreateVectorStoreFileBatchRequest$inboundSchema2
   };
   tool$llmVectorStoresCreateFileBatch = {
@@ -143546,9 +144032,9 @@ var init_llmVectorStoresCreateFileBatch2 = __esm(() => {
     description: `Batch add multiple files to vector store
 
 Adds multiple files to a vector store in a single batch operation.`,
-    args: args309,
-    tool: async (client, args310, ctx) => {
-      const [result, apiCall] = await llmVectorStoresCreateFileBatch(client, args310.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args310,
+    tool: async (client, args311, ctx) => {
+      const [result, apiCall] = await llmVectorStoresCreateFileBatch(client, args311.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143563,9 +144049,9 @@ Adds multiple files to a vector store in a single batch operation.`,
 
 // src/funcs/llmVectorStoresDelete.ts
 function llmVectorStoresDelete(client, request, options) {
-  return new APIPromise($do318(client, request, options));
+  return new APIPromise($do319(client, request, options));
 }
-async function $do318(client, request, options) {
+async function $do319(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVectorStoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143649,12 +144135,12 @@ var init_llmVectorStoresDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresDelete.ts
-var args310, tool$llmVectorStoresDelete;
+var args311, tool$llmVectorStoresDelete;
 var init_llmVectorStoresDelete2 = __esm(() => {
   init_llmVectorStoresDelete();
   init_operations();
   init_tools();
-  args310 = {
+  args311 = {
     request: DeleteVectorStoreRequest$inboundSchema
   };
   tool$llmVectorStoresDelete = {
@@ -143662,9 +144148,9 @@ var init_llmVectorStoresDelete2 = __esm(() => {
     description: `Delete a vector store
 
 Permanently deletes a vector store and its associated embeddings.`,
-    args: args310,
-    tool: async (client, args311, ctx) => {
-      const [result, apiCall] = await llmVectorStoresDelete(client, args311.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args311,
+    tool: async (client, args312, ctx) => {
+      const [result, apiCall] = await llmVectorStoresDelete(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143679,9 +144165,9 @@ Permanently deletes a vector store and its associated embeddings.`,
 
 // src/funcs/llmVectorStoresDeleteFile.ts
 function llmVectorStoresDeleteFile(client, request, options) {
-  return new APIPromise($do319(client, request, options));
+  return new APIPromise($do320(client, request, options));
 }
-async function $do319(client, request, options) {
+async function $do320(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteVectorStoreFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143769,12 +144255,12 @@ var init_llmVectorStoresDeleteFile = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresDeleteFile.ts
-var args311, tool$llmVectorStoresDeleteFile;
+var args312, tool$llmVectorStoresDeleteFile;
 var init_llmVectorStoresDeleteFile2 = __esm(() => {
   init_llmVectorStoresDeleteFile();
   init_operations();
   init_tools();
-  args311 = {
+  args312 = {
     request: DeleteVectorStoreFileRequest$inboundSchema
   };
   tool$llmVectorStoresDeleteFile = {
@@ -143782,9 +144268,9 @@ var init_llmVectorStoresDeleteFile2 = __esm(() => {
     description: `Remove file from vector store
 
 Removes a file from a vector store and deletes its associated embeddings.`,
-    args: args311,
-    tool: async (client, args312, ctx) => {
-      const [result, apiCall] = await llmVectorStoresDeleteFile(client, args312.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args312,
+    tool: async (client, args313, ctx) => {
+      const [result, apiCall] = await llmVectorStoresDeleteFile(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143799,9 +144285,9 @@ Removes a file from a vector store and deletes its associated embeddings.`,
 
 // src/funcs/llmVectorStoresGet.ts
 function llmVectorStoresGet(client, request, options) {
-  return new APIPromise($do320(client, request, options));
+  return new APIPromise($do321(client, request, options));
 }
-async function $do320(client, request, options) {
+async function $do321(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -143885,12 +144371,12 @@ var init_llmVectorStoresGet = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresGet.ts
-var args312, tool$llmVectorStoresGet;
+var args313, tool$llmVectorStoresGet;
 var init_llmVectorStoresGet2 = __esm(() => {
   init_llmVectorStoresGet();
   init_operations();
   init_tools();
-  args312 = {
+  args313 = {
     request: GetVectorStoreRequest$inboundSchema
   };
   tool$llmVectorStoresGet = {
@@ -143898,9 +144384,9 @@ var init_llmVectorStoresGet2 = __esm(() => {
     description: `Retrieve a vector store
 
 Retrieves a vector store by its ID.`,
-    args: args312,
-    tool: async (client, args313, ctx) => {
-      const [result, apiCall] = await llmVectorStoresGet(client, args313.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args313,
+    tool: async (client, args314, ctx) => {
+      const [result, apiCall] = await llmVectorStoresGet(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -143915,9 +144401,9 @@ Retrieves a vector store by its ID.`,
 
 // src/funcs/llmVectorStoresGetFile.ts
 function llmVectorStoresGetFile(client, request, options) {
-  return new APIPromise($do321(client, request, options));
+  return new APIPromise($do322(client, request, options));
 }
-async function $do321(client, request, options) {
+async function $do322(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144005,12 +144491,12 @@ var init_llmVectorStoresGetFile = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresGetFile.ts
-var args313, tool$llmVectorStoresGetFile;
+var args314, tool$llmVectorStoresGetFile;
 var init_llmVectorStoresGetFile2 = __esm(() => {
   init_llmVectorStoresGetFile();
   init_operations();
   init_tools();
-  args313 = {
+  args314 = {
     request: GetVectorStoreFileRequest$inboundSchema
   };
   tool$llmVectorStoresGetFile = {
@@ -144018,9 +144504,9 @@ var init_llmVectorStoresGetFile2 = __esm(() => {
     description: `Retrieve a vector store file
 
 Retrieves detailed information about a specific file within a vector store.`,
-    args: args313,
-    tool: async (client, args314, ctx) => {
-      const [result, apiCall] = await llmVectorStoresGetFile(client, args314.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args314,
+    tool: async (client, args315, ctx) => {
+      const [result, apiCall] = await llmVectorStoresGetFile(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144035,9 +144521,9 @@ Retrieves detailed information about a specific file within a vector store.`,
 
 // src/funcs/llmVectorStoresGetFileBatch.ts
 function llmVectorStoresGetFileBatch(client, request, options) {
-  return new APIPromise($do322(client, request, options));
+  return new APIPromise($do323(client, request, options));
 }
-async function $do322(client, request, options) {
+async function $do323(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreFileBatchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144125,12 +144611,12 @@ var init_llmVectorStoresGetFileBatch = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresGetFileBatch.ts
-var args314, tool$llmVectorStoresGetFileBatch;
+var args315, tool$llmVectorStoresGetFileBatch;
 var init_llmVectorStoresGetFileBatch2 = __esm(() => {
   init_llmVectorStoresGetFileBatch();
   init_operations();
   init_tools();
-  args314 = {
+  args315 = {
     request: GetVectorStoreFileBatchRequest$inboundSchema
   };
   tool$llmVectorStoresGetFileBatch = {
@@ -144138,9 +144624,9 @@ var init_llmVectorStoresGetFileBatch2 = __esm(() => {
     description: `Retrieve file batch status
 
 Retrieves the status of a specific file batch operation within a vector store.`,
-    args: args314,
-    tool: async (client, args315, ctx) => {
-      const [result, apiCall] = await llmVectorStoresGetFileBatch(client, args315.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args315,
+    tool: async (client, args316, ctx) => {
+      const [result, apiCall] = await llmVectorStoresGetFileBatch(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144155,9 +144641,9 @@ Retrieves the status of a specific file batch operation within a vector store.`,
 
 // src/funcs/llmVectorStoresGetFileContent.ts
 function llmVectorStoresGetFileContent(client, request, options) {
-  return new APIPromise($do323(client, request, options));
+  return new APIPromise($do324(client, request, options));
 }
-async function $do323(client, request, options) {
+async function $do324(client, request, options) {
   const parsed = safeParse4(request, (value) => GetVectorStoreFileContentRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144245,12 +144731,12 @@ var init_llmVectorStoresGetFileContent = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresGetFileContent.ts
-var args315, tool$llmVectorStoresGetFileContent;
+var args316, tool$llmVectorStoresGetFileContent;
 var init_llmVectorStoresGetFileContent2 = __esm(() => {
   init_llmVectorStoresGetFileContent();
   init_operations();
   init_tools();
-  args315 = {
+  args316 = {
     request: GetVectorStoreFileContentRequest$inboundSchema
   };
   tool$llmVectorStoresGetFileContent = {
@@ -144258,9 +144744,9 @@ var init_llmVectorStoresGetFileContent2 = __esm(() => {
     description: `Retrieve parsed file content
 
 Retrieves the complete parsed contents of a file within a vector store.`,
-    args: args315,
-    tool: async (client, args316, ctx) => {
-      const [result, apiCall] = await llmVectorStoresGetFileContent(client, args316.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args316,
+    tool: async (client, args317, ctx) => {
+      const [result, apiCall] = await llmVectorStoresGetFileContent(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144275,9 +144761,9 @@ Retrieves the complete parsed contents of a file within a vector store.`,
 
 // src/funcs/llmVectorStoresList.ts
 function llmVectorStoresList(client, request, options) {
-  return new APIPromise($do324(client, request, options));
+  return new APIPromise($do325(client, request, options));
 }
-async function $do324(client, request, options) {
+async function $do325(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVectorStoresRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144362,12 +144848,12 @@ var init_llmVectorStoresList = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresList.ts
-var args316, tool$llmVectorStoresList;
+var args317, tool$llmVectorStoresList;
 var init_llmVectorStoresList2 = __esm(() => {
   init_llmVectorStoresList();
   init_operations();
   init_tools();
-  args316 = {
+  args317 = {
     request: ListVectorStoresRequest$inboundSchema
   };
   tool$llmVectorStoresList = {
@@ -144375,9 +144861,9 @@ var init_llmVectorStoresList2 = __esm(() => {
     description: `List vector stores
 
 Retrieves a paginated list of all vector stores for the authenticated user.`,
-    args: args316,
-    tool: async (client, args317, ctx) => {
-      const [result, apiCall] = await llmVectorStoresList(client, args317.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args317,
+    tool: async (client, args318, ctx) => {
+      const [result, apiCall] = await llmVectorStoresList(client, args318.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144392,9 +144878,9 @@ Retrieves a paginated list of all vector stores for the authenticated user.`,
 
 // src/funcs/llmVectorStoresListFiles.ts
 function llmVectorStoresListFiles(client, request, options) {
-  return new APIPromise($do325(client, request, options));
+  return new APIPromise($do326(client, request, options));
 }
-async function $do325(client, request, options) {
+async function $do326(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVectorStoreFilesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144486,12 +144972,12 @@ var init_llmVectorStoresListFiles = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresListFiles.ts
-var args317, tool$llmVectorStoresListFiles;
+var args318, tool$llmVectorStoresListFiles;
 var init_llmVectorStoresListFiles2 = __esm(() => {
   init_llmVectorStoresListFiles();
   init_operations();
   init_tools();
-  args317 = {
+  args318 = {
     request: ListVectorStoreFilesRequest$inboundSchema
   };
   tool$llmVectorStoresListFiles = {
@@ -144499,9 +144985,9 @@ var init_llmVectorStoresListFiles2 = __esm(() => {
     description: `List files in a vector store
 
 Retrieves a paginated list of all files in a specific vector store.`,
-    args: args317,
-    tool: async (client, args318, ctx) => {
-      const [result, apiCall] = await llmVectorStoresListFiles(client, args318.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args318,
+    tool: async (client, args319, ctx) => {
+      const [result, apiCall] = await llmVectorStoresListFiles(client, args319.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144516,9 +145002,9 @@ Retrieves a paginated list of all files in a specific vector store.`,
 
 // src/funcs/llmVectorStoresListFilesInBatch.ts
 function llmVectorStoresListFilesInBatch(client, request, options) {
-  return new APIPromise($do326(client, request, options));
+  return new APIPromise($do327(client, request, options));
 }
-async function $do326(client, request, options) {
+async function $do327(client, request, options) {
   const parsed = safeParse4(request, (value) => ListVectorStoreFilesInBatchRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144614,12 +145100,12 @@ var init_llmVectorStoresListFilesInBatch = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresListFilesInBatch.ts
-var args318, tool$llmVectorStoresListFilesInBatch;
+var args319, tool$llmVectorStoresListFilesInBatch;
 var init_llmVectorStoresListFilesInBatch2 = __esm(() => {
   init_llmVectorStoresListFilesInBatch();
   init_operations();
   init_tools();
-  args318 = {
+  args319 = {
     request: ListVectorStoreFilesInBatchRequest$inboundSchema
   };
   tool$llmVectorStoresListFilesInBatch = {
@@ -144627,9 +145113,9 @@ var init_llmVectorStoresListFilesInBatch2 = __esm(() => {
     description: `List files in a batch
 
 Retrieves a paginated list of all files within a specific batch operation.`,
-    args: args318,
-    tool: async (client, args319, ctx) => {
-      const [result, apiCall] = await llmVectorStoresListFilesInBatch(client, args319.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args319,
+    tool: async (client, args320, ctx) => {
+      const [result, apiCall] = await llmVectorStoresListFilesInBatch(client, args320.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144644,9 +145130,9 @@ Retrieves a paginated list of all files within a specific batch operation.`,
 
 // src/funcs/llmVectorStoresSearch.ts
 function llmVectorStoresSearch(client, request, options) {
-  return new APIPromise($do327(client, request, options));
+  return new APIPromise($do328(client, request, options));
 }
-async function $do327(client, request, options) {
+async function $do328(client, request, options) {
   const parsed = safeParse4(request, (value) => SearchVectorStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144733,12 +145219,12 @@ var init_llmVectorStoresSearch = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresSearch.ts
-var args319, tool$llmVectorStoresSearch;
+var args320, tool$llmVectorStoresSearch;
 var init_llmVectorStoresSearch2 = __esm(() => {
   init_llmVectorStoresSearch();
   init_operations();
   init_tools();
-  args319 = {
+  args320 = {
     request: SearchVectorStoreRequest$inboundSchema2
   };
   tool$llmVectorStoresSearch = {
@@ -144746,9 +145232,9 @@ var init_llmVectorStoresSearch2 = __esm(() => {
     description: `Search a vector store
 
 Performs semantic search within a vector store to find the most relevant document chunks for a query.`,
-    args: args319,
-    tool: async (client, args320, ctx) => {
-      const [result, apiCall] = await llmVectorStoresSearch(client, args320.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args320,
+    tool: async (client, args321, ctx) => {
+      const [result, apiCall] = await llmVectorStoresSearch(client, args321.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144763,9 +145249,9 @@ Performs semantic search within a vector store to find the most relevant documen
 
 // src/funcs/llmVectorStoresUpdate.ts
 function llmVectorStoresUpdate(client, request, options) {
-  return new APIPromise($do328(client, request, options));
+  return new APIPromise($do329(client, request, options));
 }
-async function $do328(client, request, options) {
+async function $do329(client, request, options) {
   const parsed = safeParse4(request, (value) => ModifyVectorStoreRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144852,12 +145338,12 @@ var init_llmVectorStoresUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresUpdate.ts
-var args320, tool$llmVectorStoresUpdate;
+var args321, tool$llmVectorStoresUpdate;
 var init_llmVectorStoresUpdate2 = __esm(() => {
   init_llmVectorStoresUpdate();
   init_operations();
   init_tools();
-  args320 = {
+  args321 = {
     request: ModifyVectorStoreRequest$inboundSchema2
   };
   tool$llmVectorStoresUpdate = {
@@ -144865,9 +145351,9 @@ var init_llmVectorStoresUpdate2 = __esm(() => {
     description: `Modify a vector store
 
 Updates the properties of an existing vector store.`,
-    args: args320,
-    tool: async (client, args321, ctx) => {
-      const [result, apiCall] = await llmVectorStoresUpdate(client, args321.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args321,
+    tool: async (client, args322, ctx) => {
+      const [result, apiCall] = await llmVectorStoresUpdate(client, args322.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -144882,9 +145368,9 @@ Updates the properties of an existing vector store.`,
 
 // src/funcs/llmVectorStoresUpdateFile.ts
 function llmVectorStoresUpdateFile(client, request, options) {
-  return new APIPromise($do329(client, request, options));
+  return new APIPromise($do330(client, request, options));
 }
-async function $do329(client, request, options) {
+async function $do330(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateVectorStoreFileAttributesRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -144973,12 +145459,12 @@ var init_llmVectorStoresUpdateFile = __esm(() => {
 });
 
 // src/mcp-server/tools/llmVectorStoresUpdateFile.ts
-var args321, tool$llmVectorStoresUpdateFile;
+var args322, tool$llmVectorStoresUpdateFile;
 var init_llmVectorStoresUpdateFile2 = __esm(() => {
   init_llmVectorStoresUpdateFile();
   init_operations();
   init_tools();
-  args321 = {
+  args322 = {
     request: UpdateVectorStoreFileAttributesRequest$inboundSchema2
   };
   tool$llmVectorStoresUpdateFile = {
@@ -144986,9 +145472,9 @@ var init_llmVectorStoresUpdateFile2 = __esm(() => {
     description: `Update file attributes
 
 Updates the metadata attributes attached to a file within a vector store.`,
-    args: args321,
-    tool: async (client, args322, ctx) => {
-      const [result, apiCall] = await llmVectorStoresUpdateFile(client, args322.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args322,
+    tool: async (client, args323, ctx) => {
+      const [result, apiCall] = await llmVectorStoresUpdateFile(client, args323.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145003,9 +145489,9 @@ Updates the metadata attributes attached to a file within a vector store.`,
 
 // src/funcs/permissionsLlmCheck.ts
 function permissionsLlmCheck(client, request, options) {
-  return new APIPromise($do330(client, request, options));
+  return new APIPromise($do331(client, request, options));
 }
-async function $do330(client, request, options) {
+async function $do331(client, request, options) {
   const parsed = safeParse4(request, (value) => LlmCheckRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145089,12 +145575,12 @@ var init_permissionsLlmCheck = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsLlmCheck.ts
-var args322, tool$permissionsLlmCheck;
+var args323, tool$permissionsLlmCheck;
 var init_permissionsLlmCheck2 = __esm(() => {
   init_permissionsLlmCheck();
   init_operations();
   init_tools();
-  args322 = {
+  args323 = {
     request: LlmCheckRequest$inboundSchema
   };
   tool$permissionsLlmCheck = {
@@ -145102,9 +145588,9 @@ var init_permissionsLlmCheck2 = __esm(() => {
     description: `Check user permission
 
 Check whether the authenticated caller has a specific role on a resource.`,
-    args: args322,
-    tool: async (client, args323, ctx) => {
-      const [result, apiCall] = await permissionsLlmCheck(client, args323.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args323,
+    tool: async (client, args324, ctx) => {
+      const [result, apiCall] = await permissionsLlmCheck(client, args324.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145119,9 +145605,9 @@ Check whether the authenticated caller has a specific role on a resource.`,
 
 // src/funcs/permissionsLlmGrant.ts
 function permissionsLlmGrant(client, request, options) {
-  return new APIPromise($do331(client, request, options));
+  return new APIPromise($do332(client, request, options));
 }
-async function $do331(client, request, options) {
+async function $do332(client, request, options) {
   const parsed = safeParse4(request, (value) => LlmGrantRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145202,12 +145688,12 @@ var init_permissionsLlmGrant = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsLlmGrant.ts
-var args323, tool$permissionsLlmGrant;
+var args324, tool$permissionsLlmGrant;
 var init_permissionsLlmGrant2 = __esm(() => {
   init_permissionsLlmGrant();
   init_operations();
   init_tools();
-  args323 = {
+  args324 = {
     request: LlmGrantRequest$inboundSchema
   };
   tool$permissionsLlmGrant = {
@@ -145215,9 +145701,9 @@ var init_permissionsLlmGrant2 = __esm(() => {
     description: `Grant permission to a user or make public
 
 Grant a role to a user for a resource, or grant public access by using "*" as userId. Only owners can grant permissions. Public access is allowed only for writer and reader roles.`,
-    args: args323,
-    tool: async (client, args324, ctx) => {
-      const [result, apiCall] = await permissionsLlmGrant(client, args324.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args324,
+    tool: async (client, args325, ctx) => {
+      const [result, apiCall] = await permissionsLlmGrant(client, args325.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145231,9 +145717,9 @@ Grant a role to a user for a resource, or grant public access by using "*" as us
 
 // src/funcs/permissionsLlmRevoke.ts
 function permissionsLlmRevoke(client, request, options) {
-  return new APIPromise($do332(client, request, options));
+  return new APIPromise($do333(client, request, options));
 }
-async function $do332(client, request, options) {
+async function $do333(client, request, options) {
   const parsed = safeParse4(request, (value) => LlmRevokeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145314,12 +145800,12 @@ var init_permissionsLlmRevoke = __esm(() => {
 });
 
 // src/mcp-server/tools/permissionsLlmRevoke.ts
-var args324, tool$permissionsLlmRevoke;
+var args325, tool$permissionsLlmRevoke;
 var init_permissionsLlmRevoke2 = __esm(() => {
   init_permissionsLlmRevoke();
   init_operations();
   init_tools();
-  args324 = {
+  args325 = {
     request: LlmRevokeRequest$inboundSchema
   };
   tool$permissionsLlmRevoke = {
@@ -145327,9 +145813,9 @@ var init_permissionsLlmRevoke2 = __esm(() => {
     description: `Revoke permission from a user or remove public access
 
 Revoke a role from a user for a resource, or remove public access by using "*" as userId. Only owners can revoke permissions.`,
-    args: args324,
-    tool: async (client, args325, ctx) => {
-      const [result, apiCall] = await permissionsLlmRevoke(client, args325.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args325,
+    tool: async (client, args326, ctx) => {
+      const [result, apiCall] = await permissionsLlmRevoke(client, args326.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145343,9 +145829,9 @@ Revoke a role from a user for a resource, or remove public access by using "*" a
 
 // src/funcs/reposCreate.ts
 function reposCreate(client, request, options) {
-  return new APIPromise($do333(client, request, options));
+  return new APIPromise($do334(client, request, options));
 }
-async function $do333(client, request, options) {
+async function $do334(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateRepoRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145428,12 +145914,12 @@ var init_reposCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/reposCreate.ts
-var args325, tool$reposCreate;
+var args326, tool$reposCreate;
 var init_reposCreate2 = __esm(() => {
   init_reposCreate();
   init_operations();
   init_tools();
-  args325 = {
+  args326 = {
     request: CreateRepoRequest$inboundSchema2
   };
   tool$reposCreate = {
@@ -145444,9 +145930,9 @@ Provisions a repository (org owner/admin only): DB insert
 (authoritative) → Gitea create (rolled back on failure). The repository
 belongs to the caller's org.
 `,
-    args: args325,
-    tool: async (client, args326, ctx) => {
-      const [result, apiCall] = await reposCreate(client, args326.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args326,
+    tool: async (client, args327, ctx) => {
+      const [result, apiCall] = await reposCreate(client, args327.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145461,9 +145947,9 @@ belongs to the caller's org.
 
 // src/funcs/reposDelete.ts
 function reposDelete(client, request, options) {
-  return new APIPromise($do334(client, request, options));
+  return new APIPromise($do335(client, request, options));
 }
-async function $do334(client, request, options) {
+async function $do335(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteRepoRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145555,12 +146041,12 @@ var init_reposDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/reposDelete.ts
-var args326, tool$reposDelete;
+var args327, tool$reposDelete;
 var init_reposDelete2 = __esm(() => {
   init_reposDelete();
   init_operations();
   init_tools();
-  args326 = {
+  args327 = {
     request: DeleteRepoRequest$inboundSchema
   };
   tool$reposDelete = {
@@ -145570,9 +146056,9 @@ var init_reposDelete2 = __esm(() => {
 Removes a repository; org owner/admin only. The DB delete is
 authoritative; the Gitea teardown is best-effort cleanup.
 `,
-    args: args326,
-    tool: async (client, args327, ctx) => {
-      const [result, apiCall] = await reposDelete(client, args327.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args327,
+    tool: async (client, args328, ctx) => {
+      const [result, apiCall] = await reposDelete(client, args328.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145586,9 +146072,9 @@ authoritative; the Gitea teardown is best-effort cleanup.
 
 // src/funcs/reposGet.ts
 function reposGet(client, request, options) {
-  return new APIPromise($do335(client, request, options));
+  return new APIPromise($do336(client, request, options));
 }
-async function $do335(client, request, options) {
+async function $do336(client, request, options) {
   const parsed = safeParse4(request, (value) => GetRepoRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145680,12 +146166,12 @@ var init_reposGet = __esm(() => {
 });
 
 // src/mcp-server/tools/reposGet.ts
-var args327, tool$reposGet;
+var args328, tool$reposGet;
 var init_reposGet2 = __esm(() => {
   init_reposGet();
   init_operations();
   init_tools();
-  args327 = {
+  args328 = {
     request: GetRepoRequest$inboundSchema
   };
   tool$reposGet = {
@@ -145695,9 +146181,9 @@ var init_reposGet2 = __esm(() => {
 Reads a single repository after the org+role access check (org
 owner/admin of the repository's org only).
 `,
-    args: args327,
-    tool: async (client, args328, ctx) => {
-      const [result, apiCall] = await reposGet(client, args328.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args328,
+    tool: async (client, args329, ctx) => {
+      const [result, apiCall] = await reposGet(client, args329.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145712,9 +146198,9 @@ owner/admin of the repository's org only).
 
 // src/funcs/reposList.ts
 function reposList(client, request, options) {
-  return new APIPromise($do336(client, request, options));
+  return new APIPromise($do337(client, request, options));
 }
-async function $do336(client, request, options) {
+async function $do337(client, request, options) {
   const parsed = safeParse4(request, (value) => ListReposRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145795,12 +146281,12 @@ var init_reposList = __esm(() => {
 });
 
 // src/mcp-server/tools/reposList.ts
-var args328, tool$reposList;
+var args329, tool$reposList;
 var init_reposList2 = __esm(() => {
   init_reposList();
   init_operations();
   init_tools();
-  args328 = {
+  args329 = {
     request: ListReposRequest$inboundSchema
   };
   tool$reposList = {
@@ -145810,9 +146296,9 @@ var init_reposList2 = __esm(() => {
 Returns every repository in the caller's org (org owner/admin only).
 Pure DB read.
 `,
-    args: args328,
-    tool: async (client, args329, ctx) => {
-      const [result, apiCall] = await reposList(client, args329.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args329,
+    tool: async (client, args330, ctx) => {
+      const [result, apiCall] = await reposList(client, args330.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145827,9 +146313,9 @@ Pure DB read.
 
 // src/funcs/reposUpdate.ts
 function reposUpdate(client, request, options) {
-  return new APIPromise($do337(client, request, options));
+  return new APIPromise($do338(client, request, options));
 }
-async function $do337(client, request, options) {
+async function $do338(client, request, options) {
   const parsed = safeParse4(request, (value) => PatchRepoRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -145922,12 +146408,12 @@ var init_reposUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/reposUpdate.ts
-var args329, tool$reposUpdate;
+var args330, tool$reposUpdate;
 var init_reposUpdate2 = __esm(() => {
   init_reposUpdate();
   init_operations();
   init_tools();
-  args329 = {
+  args330 = {
     request: PatchRepoRequest$inboundSchema2
   };
   tool$reposUpdate = {
@@ -145938,9 +146424,9 @@ Applies a label-only update (name/description); org owner/admin only.
 The repository id is stable, so a rename is a one-row DB update — no
 Gitea write. Omitted fields are left unchanged.
 `,
-    args: args329,
-    tool: async (client, args330, ctx) => {
-      const [result, apiCall] = await reposUpdate(client, args330.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args330,
+    tool: async (client, args331, ctx) => {
+      const [result, apiCall] = await reposUpdate(client, args331.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -145955,9 +146441,9 @@ Gitea write. Omitted fields are left unchanged.
 
 // src/funcs/sandboxCreate.ts
 function sandboxCreate(client, request, options) {
-  return new APIPromise($do338(client, request, options));
+  return new APIPromise($do339(client, request, options));
 }
-async function $do338(client, request, options) {
+async function $do339(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146042,12 +146528,12 @@ var init_sandboxCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxCreate.ts
-var args330, tool$sandboxCreate;
+var args331, tool$sandboxCreate;
 var init_sandboxCreate2 = __esm(() => {
   init_sandboxCreate();
   init_operations();
   init_tools();
-  args330 = {
+  args331 = {
     request: CreateSessionRequest$inboundSchema2
   };
   tool$sandboxCreate = {
@@ -146055,9 +146541,9 @@ var init_sandboxCreate2 = __esm(() => {
     description: `Create Session
 
 Create a sandbox session and return its public session metadata, session token, and provider. Set \`session_kind\` to \`browser\` to start a browser-backed session instead of a standard command/code sandbox. Set \`queue_if_full\` to \`true\` to queue the request instead of failing when runner capacity is temporarily unavailable. It does not queue requests for session kinds the deployment does not support. Browser sessions require a Firecracker-backed deployment; standard-only deployments reject them immediately with \`browser_sessions_not_enabled\`.`,
-    args: args330,
-    tool: async (client, args331, ctx) => {
-      const [result, apiCall] = await sandboxCreate(client, args331.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args331,
+    tool: async (client, args332, ctx) => {
+      const [result, apiCall] = await sandboxCreate(client, args332.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146072,9 +146558,9 @@ Create a sandbox session and return its public session metadata, session token,
 
 // src/funcs/sandboxDownloadArchive.ts
 function sandboxDownloadArchive(client, request, options) {
-  return new APIPromise($do339(client, request, options));
+  return new APIPromise($do340(client, request, options));
 }
-async function $do339(client, request, options) {
+async function $do340(client, request, options) {
   const parsed = safeParse4(request, (value) => DownloadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146171,12 +146657,12 @@ var init_sandboxDownloadArchive = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxDownloadArchive.ts
-var args331, tool$sandboxDownloadArchive;
+var args332, tool$sandboxDownloadArchive;
 var init_sandboxDownloadArchive2 = __esm(() => {
   init_sandboxDownloadArchive();
   init_operations();
   init_tools();
-  args331 = {
+  args332 = {
     request: DownloadWorkspaceArchiveRequest$inboundSchema
   };
   tool$sandboxDownloadArchive = {
@@ -146184,9 +146670,9 @@ var init_sandboxDownloadArchive2 = __esm(() => {
     description: `Download Workspace Archive
 
 Download a zip archive containing the selected workspace paths.`,
-    args: args331,
-    tool: async (client, args332, ctx) => {
-      const [result, apiCall] = await sandboxDownloadArchive(client, args332.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args332,
+    tool: async (client, args333, ctx) => {
+      const [result, apiCall] = await sandboxDownloadArchive(client, args333.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146201,9 +146687,9 @@ Download a zip archive containing the selected workspace paths.`,
 
 // src/funcs/sandboxDownloadFile.ts
 function sandboxDownloadFile(client, request, options) {
-  return new APIPromise($do340(client, request, options));
+  return new APIPromise($do341(client, request, options));
 }
-async function $do340(client, request, options) {
+async function $do341(client, request, options) {
   const parsed = safeParse4(request, (value) => DownloadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146299,12 +146785,12 @@ var init_sandboxDownloadFile = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxDownloadFile.ts
-var args332, tool$sandboxDownloadFile;
+var args333, tool$sandboxDownloadFile;
 var init_sandboxDownloadFile2 = __esm(() => {
   init_sandboxDownloadFile();
   init_operations();
   init_tools();
-  args332 = {
+  args333 = {
     request: DownloadWorkspaceFileRequest$inboundSchema
   };
   tool$sandboxDownloadFile = {
@@ -146312,9 +146798,9 @@ var init_sandboxDownloadFile2 = __esm(() => {
     description: `Download Workspace File
 
 Download raw bytes from a file in the session workspace.`,
-    args: args332,
-    tool: async (client, args333, ctx) => {
-      const [result, apiCall] = await sandboxDownloadFile(client, args333.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args333,
+    tool: async (client, args334, ctx) => {
+      const [result, apiCall] = await sandboxDownloadFile(client, args334.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146329,9 +146815,9 @@ Download raw bytes from a file in the session workspace.`,
 
 // src/funcs/sandboxGet.ts
 function sandboxGet(client, request, options) {
-  return new APIPromise($do341(client, request, options));
+  return new APIPromise($do342(client, request, options));
 }
-async function $do341(client, request, options) {
+async function $do342(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSessionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146419,12 +146905,12 @@ var init_sandboxGet = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxGet.ts
-var args333, tool$sandboxGet;
+var args334, tool$sandboxGet;
 var init_sandboxGet2 = __esm(() => {
   init_sandboxGet();
   init_operations();
   init_tools();
-  args333 = {
+  args334 = {
     request: GetSessionRequest$inboundSchema
   };
   tool$sandboxGet = {
@@ -146432,9 +146918,9 @@ var init_sandboxGet2 = __esm(() => {
     description: `Get Session
 
 Return the current state, configuration, and resource allocation for a sandbox session.`,
-    args: args333,
-    tool: async (client, args334, ctx) => {
-      const [result, apiCall] = await sandboxGet(client, args334.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args334,
+    tool: async (client, args335, ctx) => {
+      const [result, apiCall] = await sandboxGet(client, args335.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146449,9 +146935,9 @@ Return the current state, configuration, and resource allocation for a sandbox s
 
 // src/funcs/sandboxGetBrowserUrl.ts
 function sandboxGetBrowserUrl(client, request, options) {
-  return new APIPromise($do342(client, request, options));
+  return new APIPromise($do343(client, request, options));
 }
-async function $do342(client, request, options) {
+async function $do343(client, request, options) {
   const parsed = safeParse4(request, (value) => GetBrowserSessionUrlRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146543,12 +147029,12 @@ var init_sandboxGetBrowserUrl = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxGetBrowserUrl.ts
-var args334, tool$sandboxGetBrowserUrl;
+var args335, tool$sandboxGetBrowserUrl;
 var init_sandboxGetBrowserUrl2 = __esm(() => {
   init_sandboxGetBrowserUrl();
   init_operations();
   init_tools();
-  args334 = {
+  args335 = {
     request: GetBrowserSessionUrlRequest$inboundSchema
   };
   tool$sandboxGetBrowserUrl = {
@@ -146556,9 +147042,9 @@ var init_sandboxGetBrowserUrl2 = __esm(() => {
     description: `Get Browser Session URL
 
 Return the public gateway URL for a browser session's Chrome DevTools Protocol endpoint. Playwright can use this HTTP endpoint directly. For clients that require a WebSocket endpoint, request \`json/version\` and use its rewritten \`webSocketDebuggerUrl\`. Insert subpaths before the query string; for example, use \`/ports/9222/json/version?session_token=...\`. Send the same MKA1 API-key authorization header on the HTTP and WebSocket requests. Standard sessions do not expose a public URL; use the command, code, and workspace operations instead.`,
-    args: args334,
-    tool: async (client, args335, ctx) => {
-      const [result, apiCall] = await sandboxGetBrowserUrl(client, args335.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args335,
+    tool: async (client, args336, ctx) => {
+      const [result, apiCall] = await sandboxGetBrowserUrl(client, args336.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146573,9 +147059,9 @@ Return the public gateway URL for a browser session's Chrome DevTools Protocol e
 
 // src/funcs/sandboxGetPricing.ts
 function sandboxGetPricing(client, options) {
-  return new APIPromise($do343(client, options));
+  return new APIPromise($do344(client, options));
 }
-async function $do343(client, options) {
+async function $do344(client, options) {
   const path = pathToFunc("/api/v1/sandbox/pricing")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -146667,9 +147153,9 @@ Current sandbox pricing rate card, keyed by SKU (\`standard\`, \`browser\`, \`ev
 
 // src/funcs/sandboxGetWorkspace.ts
 function sandboxGetWorkspace(client, request, options) {
-  return new APIPromise($do344(client, request, options));
+  return new APIPromise($do345(client, request, options));
 }
-async function $do344(client, request, options) {
+async function $do345(client, request, options) {
   const parsed = safeParse4(request, (value) => GetWorkspaceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146761,12 +147247,12 @@ var init_sandboxGetWorkspace = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxGetWorkspace.ts
-var args335, tool$sandboxGetWorkspace;
+var args336, tool$sandboxGetWorkspace;
 var init_sandboxGetWorkspace2 = __esm(() => {
   init_sandboxGetWorkspace();
   init_operations();
   init_tools();
-  args335 = {
+  args336 = {
     request: GetWorkspaceRequest$inboundSchema
   };
   tool$sandboxGetWorkspace = {
@@ -146774,9 +147260,9 @@ var init_sandboxGetWorkspace2 = __esm(() => {
     description: `Get Workspace Manifest
 
 List files currently stored in the session workspace, including paths, sizes, and etags.`,
-    args: args335,
-    tool: async (client, args336, ctx) => {
-      const [result, apiCall] = await sandboxGetWorkspace(client, args336.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args336,
+    tool: async (client, args337, ctx) => {
+      const [result, apiCall] = await sandboxGetWorkspace(client, args337.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146791,9 +147277,9 @@ List files currently stored in the session workspace, including paths, sizes, an
 
 // src/funcs/sandboxList.ts
 function sandboxList(client, request, options) {
-  return new APIPromise($do345(client, request, options));
+  return new APIPromise($do346(client, request, options));
 }
-async function $do345(client, request, options) {
+async function $do346(client, request, options) {
   const parsed = safeParse4(request, (value) => ListSessionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -146876,12 +147362,12 @@ var init_sandboxList = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxList.ts
-var args336, tool$sandboxList;
+var args337, tool$sandboxList;
 var init_sandboxList2 = __esm(() => {
   init_sandboxList();
   init_operations();
   init_tools();
-  args336 = {
+  args337 = {
     request: ListSessionsRequest$inboundSchema
   };
   tool$sandboxList = {
@@ -146889,9 +147375,9 @@ var init_sandboxList2 = __esm(() => {
     description: `List Sessions
 
 List sandbox sessions visible to the authenticated caller.`,
-    args: args336,
-    tool: async (client, args337, ctx) => {
-      const [result, apiCall] = await sandboxList(client, args337.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args337,
+    tool: async (client, args338, ctx) => {
+      const [result, apiCall] = await sandboxList(client, args338.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -146906,9 +147392,9 @@ List sandbox sessions visible to the authenticated caller.`,
 
 // src/funcs/sandboxProxyBrowserPortRequest.ts
 function sandboxProxyBrowserPortRequest(client, request, options) {
-  return new APIPromise($do346(client, request, options));
+  return new APIPromise($do347(client, request, options));
 }
-async function $do346(client, request, options) {
+async function $do347(client, request, options) {
   const parsed = safeParse4(request, (value) => ProxyBrowserPortRequestRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147008,12 +147494,12 @@ var init_sandboxProxyBrowserPortRequest = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxProxyBrowserPortRequest.ts
-var args337, tool$sandboxProxyBrowserPortRequest;
+var args338, tool$sandboxProxyBrowserPortRequest;
 var init_sandboxProxyBrowserPortRequest2 = __esm(() => {
   init_sandboxProxyBrowserPortRequest();
   init_operations();
   init_tools();
-  args337 = {
+  args338 = {
     request: ProxyBrowserPortRequestRequest$inboundSchema
   };
   tool$sandboxProxyBrowserPortRequest = {
@@ -147021,9 +147507,9 @@ var init_sandboxProxyBrowserPortRequest2 = __esm(() => {
     description: `Proxy Browser Port Request
 
 Proxy an HTTP request to an exposed browser-session port through the gateway. Use the URL returned by \`GET /sessions/{session_id}/browser-url\` as the base. Insert CDP subpaths such as \`json/version\` or \`json/list\` before its query string, preserving the \`session_token\` parameter. This low-level proxy is intended for browser sessions on port \`9222\` and still requires the normal MKA1 API-key authorization header.`,
-    args: args337,
-    tool: async (client, args338, ctx) => {
-      const [result, apiCall] = await sandboxProxyBrowserPortRequest(client, args338.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args338,
+    tool: async (client, args339, ctx) => {
+      const [result, apiCall] = await sandboxProxyBrowserPortRequest(client, args339.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147038,9 +147524,9 @@ Proxy an HTTP request to an exposed browser-session port through the gateway. Us
 
 // src/funcs/sandboxRunCode.ts
 function sandboxRunCode(client, request, options) {
-  return new APIPromise($do347(client, request, options));
+  return new APIPromise($do348(client, request, options));
 }
-async function $do347(client, request, options) {
+async function $do348(client, request, options) {
   const parsed = safeParse4(request, (value) => RunCodeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147129,12 +147615,12 @@ var init_sandboxRunCode = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxRunCode.ts
-var args338, tool$sandboxRunCode;
+var args339, tool$sandboxRunCode;
 var init_sandboxRunCode2 = __esm(() => {
   init_sandboxRunCode();
   init_operations();
   init_tools();
-  args338 = {
+  args339 = {
     request: RunCodeRequest$inboundSchema
   };
   tool$sandboxRunCode = {
@@ -147142,9 +147628,9 @@ var init_sandboxRunCode2 = __esm(() => {
     description: `Run Code
 
 Execute source code in the session workspace using a supported runtime and return the execution result.`,
-    args: args338,
-    tool: async (client, args339, ctx) => {
-      const [result, apiCall] = await sandboxRunCode(client, args339.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args339,
+    tool: async (client, args340, ctx) => {
+      const [result, apiCall] = await sandboxRunCode(client, args340.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147159,9 +147645,9 @@ Execute source code in the session workspace using a supported runtime and retur
 
 // src/funcs/sandboxRunCommand.ts
 function sandboxRunCommand(client, request, options) {
-  return new APIPromise($do348(client, request, options));
+  return new APIPromise($do349(client, request, options));
 }
-async function $do348(client, request, options) {
+async function $do349(client, request, options) {
   const parsed = safeParse4(request, (value) => RunCommandRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147250,12 +147736,12 @@ var init_sandboxRunCommand = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxRunCommand.ts
-var args339, tool$sandboxRunCommand;
+var args340, tool$sandboxRunCommand;
 var init_sandboxRunCommand2 = __esm(() => {
   init_sandboxRunCommand();
   init_operations();
   init_tools();
-  args339 = {
+  args340 = {
     request: RunCommandRequest$inboundSchema
   };
   tool$sandboxRunCommand = {
@@ -147263,9 +147749,9 @@ var init_sandboxRunCommand2 = __esm(() => {
     description: `Run Command
 
 Run a command in the session workspace and return stdout, stderr, exit code, and changed files.`,
-    args: args339,
-    tool: async (client, args340, ctx) => {
-      const [result, apiCall] = await sandboxRunCommand(client, args340.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args340,
+    tool: async (client, args341, ctx) => {
+      const [result, apiCall] = await sandboxRunCommand(client, args341.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147280,9 +147766,9 @@ Run a command in the session workspace and return stdout, stderr, exit code, and
 
 // src/funcs/sandboxSetPricing.ts
 function sandboxSetPricing(client, request, options) {
-  return new APIPromise($do349(client, request, options));
+  return new APIPromise($do350(client, request, options));
 }
-async function $do349(client, request, options) {
+async function $do350(client, request, options) {
   const parsed = safeParse4(request, (value) => SandboxPricingUpdate$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147363,12 +147849,12 @@ var init_sandboxSetPricing = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxSetPricing.ts
-var args340, tool$sandboxSetPricing;
+var args341, tool$sandboxSetPricing;
 var init_sandboxSetPricing2 = __esm(() => {
   init_sandboxSetPricing();
   init_components();
   init_tools();
-  args340 = {
+  args341 = {
     request: SandboxPricingUpdate$inboundSchema
   };
   tool$sandboxSetPricing = {
@@ -147376,9 +147862,9 @@ var init_sandboxSetPricing2 = __esm(() => {
     description: `Set Sandbox Pricing
 
 Replace the sandbox pricing rate card. Full-replace semantics: SKUs omitted from the request become unpriced and accrue no spend. Takes effect on the next meter window without a restart. Cluster admins only.`,
-    args: args340,
-    tool: async (client, args341, ctx) => {
-      const [result, apiCall] = await sandboxSetPricing(client, args341.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args341,
+    tool: async (client, args342, ctx) => {
+      const [result, apiCall] = await sandboxSetPricing(client, args342.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147393,9 +147879,9 @@ Replace the sandbox pricing rate card. Full-replace semantics: SKUs omitted from
 
 // src/funcs/sandboxTerminate.ts
 function sandboxTerminate(client, request, options) {
-  return new APIPromise($do350(client, request, options));
+  return new APIPromise($do351(client, request, options));
 }
-async function $do350(client, request, options) {
+async function $do351(client, request, options) {
   const parsed = safeParse4(request, (value) => TerminateSessionRequest$outboundSchema2.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147486,12 +147972,12 @@ var init_sandboxTerminate = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxTerminate.ts
-var args341, tool$sandboxTerminate;
+var args342, tool$sandboxTerminate;
 var init_sandboxTerminate2 = __esm(() => {
   init_sandboxTerminate();
   init_operations();
   init_tools();
-  args341 = {
+  args342 = {
     request: TerminateSessionRequest$inboundSchema2
   };
   tool$sandboxTerminate = {
@@ -147499,9 +147985,9 @@ var init_sandboxTerminate2 = __esm(() => {
     description: `Terminate Session
 
 Stop a sandbox session and release the backing sandbox resources.`,
-    args: args341,
-    tool: async (client, args342, ctx) => {
-      const [result, apiCall] = await sandboxTerminate(client, args342.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args342,
+    tool: async (client, args343, ctx) => {
+      const [result, apiCall] = await sandboxTerminate(client, args343.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147516,9 +148002,9 @@ Stop a sandbox session and release the backing sandbox resources.`,
 
 // src/funcs/sandboxUploadArchive.ts
 function sandboxUploadArchive(client, request, options) {
-  return new APIPromise($do351(client, request, options));
+  return new APIPromise($do352(client, request, options));
 }
-async function $do351(client, request, options) {
+async function $do352(client, request, options) {
   const parsed = safeParse4(request, (value) => UploadWorkspaceArchiveRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147611,12 +148097,12 @@ var init_sandboxUploadArchive = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxUploadArchive.ts
-var args342, tool$sandboxUploadArchive;
+var args343, tool$sandboxUploadArchive;
 var init_sandboxUploadArchive2 = __esm(() => {
   init_sandboxUploadArchive();
   init_operations();
   init_tools();
-  args342 = {
+  args343 = {
     request: UploadWorkspaceArchiveRequest$inboundSchema
   };
   tool$sandboxUploadArchive = {
@@ -147624,9 +148110,9 @@ var init_sandboxUploadArchive2 = __esm(() => {
     description: `Upload Workspace Archive
 
 Upload a zip archive and extract its files into the session workspace.`,
-    args: args342,
-    tool: async (client, args343, ctx) => {
-      const [result, apiCall] = await sandboxUploadArchive(client, args343.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args343,
+    tool: async (client, args344, ctx) => {
+      const [result, apiCall] = await sandboxUploadArchive(client, args344.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147641,9 +148127,9 @@ Upload a zip archive and extract its files into the session workspace.`,
 
 // src/funcs/sandboxUploadFile.ts
 function sandboxUploadFile(client, request, options) {
-  return new APIPromise($do352(client, request, options));
+  return new APIPromise($do353(client, request, options));
 }
-async function $do352(client, request, options) {
+async function $do353(client, request, options) {
   const parsed = safeParse4(request, (value) => UploadWorkspaceFileRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147740,12 +148226,12 @@ var init_sandboxUploadFile = __esm(() => {
 });
 
 // src/mcp-server/tools/sandboxUploadFile.ts
-var args343, tool$sandboxUploadFile;
+var args344, tool$sandboxUploadFile;
 var init_sandboxUploadFile2 = __esm(() => {
   init_sandboxUploadFile();
   init_operations();
   init_tools();
-  args343 = {
+  args344 = {
     request: UploadWorkspaceFileRequest$inboundSchema
   };
   tool$sandboxUploadFile = {
@@ -147753,9 +148239,9 @@ var init_sandboxUploadFile2 = __esm(() => {
     description: `Upload Workspace File
 
 Upload raw bytes into the session workspace at the given path.`,
-    args: args343,
-    tool: async (client, args344, ctx) => {
-      const [result, apiCall] = await sandboxUploadFile(client, args344.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args344,
+    tool: async (client, args345, ctx) => {
+      const [result, apiCall] = await sandboxUploadFile(client, args345.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147770,9 +148256,9 @@ Upload raw bytes into the session workspace at the given path.`,
 
 // src/funcs/schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost.ts
 function schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, request, options) {
-  return new APIPromise($do353(client, request, options));
+  return new APIPromise($do354(client, request, options));
 }
-async function $do353(client, request, options) {
+async function $do354(client, request, options) {
   const parsed = safeParse4(request, (value) => ConnectApiV1SandboxGithubOauthConnectionsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147855,20 +148341,20 @@ var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost = __esm(() =>
 });
 
 // src/mcp-server/tools/schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost.ts
-var args344, tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost;
+var args345, tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost;
 var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost2 = __esm(() => {
   init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost();
   init_operations();
   init_tools();
-  args344 = {
+  args345 = {
     request: ConnectApiV1SandboxGithubOauthConnectionsPostRequest$inboundSchema
   };
   tool$schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost = {
     name: "schema-3-other-connect-api-v1-sandbox-github-oauth-connections-post",
     description: `Connect`,
-    args: args344,
-    tool: async (client, args345, ctx) => {
-      const [result, apiCall] = await schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, args345.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args345,
+    tool: async (client, args346, ctx) => {
+      const [result, apiCall] = await schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost(client, args346.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147883,9 +148369,9 @@ var init_schema3OtherConnectApiV1SandboxGithubOauthConnectionsPost2 = __esm(() =
 
 // src/funcs/schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost.ts
 function schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost(client, request, options) {
-  return new APIPromise($do354(client, request, options));
+  return new APIPromise($do355(client, request, options));
 }
-async function $do354(client, request, options) {
+async function $do355(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateEnvironmentApiV1SandboxEnvironmentsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -147970,20 +148456,20 @@ var init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost = __esm(() =>
 });
 
 // src/mcp-server/tools/schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost.ts
-var args345, tool$schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost;
+var args346, tool$schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost;
 var init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost2 = __esm(() => {
   init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost();
   init_operations();
   init_tools();
-  args345 = {
+  args346 = {
     request: CreateEnvironmentApiV1SandboxEnvironmentsPostRequest$inboundSchema
   };
   tool$schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost = {
     name: "schema-3-other-create-environment-api-v1-sandbox-environments-post",
     description: `Create Environment`,
-    args: args345,
-    tool: async (client, args346, ctx) => {
-      const [result, apiCall] = await schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost(client, args346.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args346,
+    tool: async (client, args347, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost(client, args347.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -147998,9 +148484,9 @@ var init_schema3OtherCreateEnvironmentApiV1SandboxEnvironmentsPost2 = __esm(() =
 
 // src/funcs/schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost.ts
 function schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, request, options) {
-  return new APIPromise($do355(client, request, options));
+  return new APIPromise($do356(client, request, options));
 }
-async function $do355(client, request, options) {
+async function $do356(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148078,20 +148564,20 @@ var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost = __esm(() =
 });
 
 // src/mcp-server/tools/schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost.ts
-var args346, tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost;
+var args347, tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost;
 var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2 = __esm(() => {
   init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost();
   init_operations();
   init_tools();
-  args346 = {
+  args347 = {
     request: CreateIntentApiV1SandboxGithubOauthIntentsPostRequest$inboundSchema
   };
   tool$schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost = {
     name: "schema-3-other-create-intent-api-v1-sandbox-github-oauth-intents-post",
     description: `Create Intent`,
-    args: args346,
-    tool: async (client, args347, ctx) => {
-      const [result, apiCall] = await schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, args347.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args347,
+    tool: async (client, args348, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost(client, args348.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148106,9 +148592,9 @@ var init_schema3OtherCreateIntentApiV1SandboxGithubOauthIntentsPost2 = __esm(()
 
 // src/funcs/schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost.ts
 function schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, request, options) {
-  return new APIPromise($do356(client, request, options));
+  return new APIPromise($do357(client, request, options));
 }
-async function $do356(client, request, options) {
+async function $do357(client, request, options) {
   const parsed = safeParse4(request, (value) => CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148199,20 +148685,20 @@ var init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullReques
 });
 
 // src/mcp-server/tools/schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost.ts
-var args347, tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost;
+var args348, tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost;
 var init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost2 = __esm(() => {
   init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost();
   init_operations();
   init_tools();
-  args347 = {
+  args348 = {
     request: CreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPostRequest$inboundSchema
   };
   tool$schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost = {
     name: "schema-3-other-create-or-update-api-v1-sandbox-sessions-session-id-github-pull-request-post",
     description: `Create Or Update`,
-    args: args347,
-    tool: async (client, args348, ctx) => {
-      const [result, apiCall] = await schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, args348.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args348,
+    tool: async (client, args349, ctx) => {
+      const [result, apiCall] = await schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullRequestPost(client, args349.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148227,9 +148713,9 @@ var init_schema3OtherCreateOrUpdateApiV1SandboxSessionsSessionIdGithubPullReques
 
 // src/funcs/schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete.ts
 function schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete(client, request, options) {
-  return new APIPromise($do357(client, request, options));
+  return new APIPromise($do358(client, request, options));
 }
-async function $do357(client, request, options) {
+async function $do358(client, request, options) {
   const parsed = safeParse4(request, (value) => DeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148317,20 +148803,20 @@ var init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelet
 });
 
 // src/mcp-server/tools/schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete.ts
-var args348, tool$schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete;
+var args349, tool$schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete;
 var init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete2 = __esm(() => {
   init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete();
   init_operations();
   init_tools();
-  args348 = {
+  args349 = {
     request: DeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDeleteRequest$inboundSchema
   };
   tool$schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete = {
     name: "schema-3-other-delete-environment-api-v1-sandbox-environments-environment-id-delete",
     description: `Delete Environment`,
-    args: args348,
-    tool: async (client, args349, ctx) => {
-      const [result, apiCall] = await schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete(client, args349.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args349,
+    tool: async (client, args350, ctx) => {
+      const [result, apiCall] = await schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelete(client, args350.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148344,9 +148830,9 @@ var init_schema3OtherDeleteEnvironmentApiV1SandboxEnvironmentsEnvironmentIdDelet
 
 // src/funcs/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
 function schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, request, options) {
-  return new APIPromise($do358(client, request, options));
+  return new APIPromise($do359(client, request, options));
 }
-async function $do358(client, request, options) {
+async function $do359(client, request, options) {
   const parsed = safeParse4(request, (value) => DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148424,20 +148910,20 @@ var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = __esm(
 });
 
 // src/mcp-server/tools/schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete.ts
-var args349, tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete;
+var args350, tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete;
 var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2 = __esm(() => {
   init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete();
   init_operations();
   init_tools();
-  args349 = {
+  args350 = {
     request: DisconnectApiV1SandboxGithubOauthConnectionsDeleteRequest$inboundSchema
   };
   tool$schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete = {
     name: "schema-3-other-disconnect-api-v1-sandbox-github-oauth-connections-delete",
     description: `Disconnect`,
-    args: args349,
-    tool: async (client, args350, ctx) => {
-      const [result, apiCall] = await schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, args350.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args350,
+    tool: async (client, args351, ctx) => {
+      const [result, apiCall] = await schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete(client, args351.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148451,9 +148937,9 @@ var init_schema3OtherDisconnectApiV1SandboxGithubOauthConnectionsDelete2 = __esm
 
 // src/funcs/schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete.ts
 function schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete(client, request, options) {
-  return new APIPromise($do359(client, request, options));
+  return new APIPromise($do360(client, request, options));
 }
-async function $do359(client, request, options) {
+async function $do360(client, request, options) {
   const parsed = safeParse4(request, (value) => DismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148548,20 +149034,20 @@ var init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubReposit
 });
 
 // src/mcp-server/tools/schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete.ts
-var args350, tool$schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete;
+var args351, tool$schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete;
 var init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete2 = __esm(() => {
   init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete();
   init_operations();
   init_tools();
-  args350 = {
+  args351 = {
     request: DismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDeleteRequest$inboundSchema
   };
   tool$schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete = {
     name: "schema-3-other-dismiss-repository-api-v1-sandbox-sessions-session-id-github-repositories-repository-id-delete",
     description: `Dismiss Repository`,
-    args: args350,
-    tool: async (client, args351, ctx) => {
-      const [result, apiCall] = await schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete(client, args351.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args351,
+    tool: async (client, args352, ctx) => {
+      const [result, apiCall] = await schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdDelete(client, args352.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148575,9 +149061,9 @@ var init_schema3OtherDismissRepositoryApiV1SandboxSessionsSessionIdGithubReposit
 
 // src/funcs/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
 function schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, request, options) {
-  return new APIPromise($do360(client, request, options));
+  return new APIPromise($do361(client, request, options));
 }
-async function $do360(client, request, options) {
+async function $do361(client, request, options) {
   const parsed = safeParse4(request, (value) => GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148663,20 +149149,20 @@ var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = __esm(
 });
 
 // src/mcp-server/tools/schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet.ts
-var args351, tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet;
+var args352, tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet;
 var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2 = __esm(() => {
   init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet();
   init_operations();
   init_tools();
-  args351 = {
+  args352 = {
     request: GetConnectionApiV1SandboxGithubOauthConnectionsGetRequest$inboundSchema
   };
   tool$schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet = {
     name: "schema-3-other-get-connection-api-v1-sandbox-github-oauth-connections-get",
     description: `Get Connection`,
-    args: args351,
-    tool: async (client, args352, ctx) => {
-      const [result, apiCall] = await schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, args352.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args352,
+    tool: async (client, args353, ctx) => {
+      const [result, apiCall] = await schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet(client, args353.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148691,9 +149177,9 @@ var init_schema3OtherGetConnectionApiV1SandboxGithubOauthConnectionsGet2 = __esm
 
 // src/funcs/schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet.ts
 function schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet(client, request, options) {
-  return new APIPromise($do361(client, request, options));
+  return new APIPromise($do362(client, request, options));
 }
-async function $do361(client, request, options) {
+async function $do362(client, request, options) {
   const parsed = safeParse4(request, (value) => GetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148781,20 +149267,20 @@ var init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet = __
 });
 
 // src/mcp-server/tools/schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet.ts
-var args352, tool$schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet;
+var args353, tool$schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet;
 var init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet2 = __esm(() => {
   init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet();
   init_operations();
   init_tools();
-  args352 = {
+  args353 = {
     request: GetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGetRequest$inboundSchema
   };
   tool$schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet = {
     name: "schema-3-other-get-environment-api-v1-sandbox-environments-environment-id-get",
     description: `Get Environment`,
-    args: args352,
-    tool: async (client, args353, ctx) => {
-      const [result, apiCall] = await schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet(client, args353.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args353,
+    tool: async (client, args354, ctx) => {
+      const [result, apiCall] = await schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet(client, args354.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148809,9 +149295,9 @@ var init_schema3OtherGetEnvironmentApiV1SandboxEnvironmentsEnvironmentIdGet2 = _
 
 // src/funcs/schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet.ts
 function schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet(client, request, options) {
-  return new APIPromise($do362(client, request, options));
+  return new APIPromise($do363(client, request, options));
 }
-async function $do362(client, request, options) {
+async function $do363(client, request, options) {
   const parsed = safeParse4(request, (value) => ListEnvironmentsApiV1SandboxEnvironmentsGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148889,20 +149375,20 @@ var init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet = __esm(() => {
 });
 
 // src/mcp-server/tools/schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet.ts
-var args353, tool$schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet;
+var args354, tool$schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet;
 var init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet2 = __esm(() => {
   init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet();
   init_operations();
   init_tools();
-  args353 = {
+  args354 = {
     request: ListEnvironmentsApiV1SandboxEnvironmentsGetRequest$inboundSchema
   };
   tool$schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet = {
     name: "schema-3-other-list-environments-api-v1-sandbox-environments-get",
     description: `List Environments`,
-    args: args353,
-    tool: async (client, args354, ctx) => {
-      const [result, apiCall] = await schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet(client, args354.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args354,
+    tool: async (client, args355, ctx) => {
+      const [result, apiCall] = await schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet(client, args355.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -148917,9 +149403,9 @@ var init_schema3OtherListEnvironmentsApiV1SandboxEnvironmentsGet2 = __esm(() =>
 
 // src/funcs/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
 function schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, request, options) {
-  return new APIPromise($do363(client, request, options));
+  return new APIPromise($do364(client, request, options));
 }
-async function $do363(client, request, options) {
+async function $do364(client, request, options) {
   const parsed = safeParse4(request, (value) => ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -148997,20 +149483,20 @@ var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = __esm((
 });
 
 // src/mcp-server/tools/schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet.ts
-var args354, tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet;
+var args355, tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet;
 var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2 = __esm(() => {
   init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet();
   init_operations();
   init_tools();
-  args354 = {
+  args355 = {
     request: ListRepositoriesApiV1SandboxGithubRepositoriesGetRequest$inboundSchema
   };
   tool$schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet = {
     name: "schema-3-other-list-repositories-api-v1-sandbox-github-repositories-get",
     description: `List Repositories`,
-    args: args354,
-    tool: async (client, args355, ctx) => {
-      const [result, apiCall] = await schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, args355.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args355,
+    tool: async (client, args356, ctx) => {
+      const [result, apiCall] = await schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet(client, args356.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149025,9 +149511,9 @@ var init_schema3OtherListRepositoriesApiV1SandboxGithubRepositoriesGet2 = __esm(
 
 // src/funcs/schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet.ts
 function schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet(client, request, options) {
-  return new APIPromise($do364(client, request, options));
+  return new APIPromise($do365(client, request, options));
 }
-async function $do364(client, request, options) {
+async function $do365(client, request, options) {
   const parsed = safeParse4(request, (value) => ManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149115,20 +149601,20 @@ var init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet
 });
 
 // src/mcp-server/tools/schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet.ts
-var args355, tool$schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet;
+var args356, tool$schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet;
 var init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet2 = __esm(() => {
   init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet();
   init_operations();
   init_tools();
-  args355 = {
+  args356 = {
     request: ManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGetRequest$inboundSchema
   };
   tool$schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet = {
     name: "schema-3-other-manifest-api-v1-sandbox-sessions-session-id-github-repositories-get",
     description: `Manifest`,
-    args: args355,
-    tool: async (client, args356, ctx) => {
-      const [result, apiCall] = await schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet(client, args356.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args356,
+    tool: async (client, args357, ctx) => {
+      const [result, apiCall] = await schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet(client, args357.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149143,9 +149629,9 @@ var init_schema3OtherManifestApiV1SandboxSessionsSessionIdGithubRepositoriesGet2
 
 // src/funcs/schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost.ts
 function schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, request, options) {
-  return new APIPromise($do365(client, request, options));
+  return new APIPromise($do366(client, request, options));
 }
-async function $do365(client, request, options) {
+async function $do366(client, request, options) {
   const parsed = safeParse4(request, (value) => PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149234,20 +149720,20 @@ var init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost = __esm(()
 });
 
 // src/mcp-server/tools/schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost.ts
-var args356, tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost;
+var args357, tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost;
 var init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost2 = __esm(() => {
   init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost();
   init_operations();
   init_tools();
-  args356 = {
+  args357 = {
     request: PushApiV1SandboxSessionsSessionIdGithubPushPostRequest$inboundSchema
   };
   tool$schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost = {
     name: "schema-3-other-push-api-v1-sandbox-sessions-session-id-github-push-post",
     description: `Push`,
-    args: args356,
-    tool: async (client, args357, ctx) => {
-      const [result, apiCall] = await schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, args357.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args357,
+    tool: async (client, args358, ctx) => {
+      const [result, apiCall] = await schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost(client, args358.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149262,9 +149748,9 @@ var init_schema3OtherPushApiV1SandboxSessionsSessionIdGithubPushPost2 = __esm(()
 
 // src/funcs/schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut.ts
 function schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut(client, request, options) {
-  return new APIPromise($do366(client, request, options));
+  return new APIPromise($do367(client, request, options));
 }
-async function $do366(client, request, options) {
+async function $do367(client, request, options) {
   const parsed = safeParse4(request, (value) => PutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPutRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149359,20 +149845,20 @@ var init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositorie
 });
 
 // src/mcp-server/tools/schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut.ts
-var args357, tool$schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut;
+var args358, tool$schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut;
 var init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut2 = __esm(() => {
   init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut();
   init_operations();
   init_tools();
-  args357 = {
+  args358 = {
     request: PutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPutRequest$inboundSchema
   };
   tool$schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut = {
     name: "schema-3-other-put-repository-api-v1-sandbox-sessions-session-id-github-repositories-repository-id-put",
     description: `Put Repository`,
-    args: args357,
-    tool: async (client, args358, ctx) => {
-      const [result, apiCall] = await schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut(client, args358.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args358,
+    tool: async (client, args359, ctx) => {
+      const [result, apiCall] = await schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositoriesRepositoryIdPut(client, args359.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149387,9 +149873,9 @@ var init_schema3OtherPutRepositoryApiV1SandboxSessionsSessionIdGithubRepositorie
 
 // src/funcs/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
 function schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, request, options) {
-  return new APIPromise($do367(client, request, options));
+  return new APIPromise($do368(client, request, options));
 }
-async function $do367(client, request, options) {
+async function $do368(client, request, options) {
   const parsed = safeParse4(request, (value) => ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149480,20 +149966,20 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost =
 });
 
 // src/mcp-server/tools/schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost.ts
-var args358, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
+var args359, tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost;
 var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2 = __esm(() => {
   init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost();
   init_operations();
   init_tools();
-  args358 = {
+  args359 = {
     request: ReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePostRequest$inboundSchema
   };
   tool$schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost = {
     name: "schema-3-other-read-clone-api-v1-sandbox-sessions-session-id-github-read-clone-post",
     description: `Read Clone`,
-    args: args358,
-    tool: async (client, args359, ctx) => {
-      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args359.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args359,
+    tool: async (client, args360, ctx) => {
+      const [result, apiCall] = await schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost(client, args360.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149508,9 +149994,9 @@ var init_schema3OtherReadCloneApiV1SandboxSessionsSessionIdGithubReadClonePost2
 
 // src/funcs/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
 function schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, request, options) {
-  return new APIPromise($do368(client, request, options));
+  return new APIPromise($do369(client, request, options));
 }
-async function $do368(client, request, options) {
+async function $do369(client, request, options) {
   const parsed = safeParse4(request, (value) => RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149588,20 +150074,20 @@ var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPos
 });
 
 // src/mcp-server/tools/schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost.ts
-var args359, tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost;
+var args360, tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost;
 var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost2 = __esm(() => {
   init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost();
   init_operations();
   init_tools();
-  args359 = {
+  args360 = {
     request: RefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPostRequest$inboundSchema
   };
   tool$schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost = {
     name: "schema-3-other-refresh-repositories-api-v1-sandbox-github-repositories-refresh-post",
     description: `Refresh Repositories`,
-    args: args359,
-    tool: async (client, args360, ctx) => {
-      const [result, apiCall] = await schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, args360.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args360,
+    tool: async (client, args361, ctx) => {
+      const [result, apiCall] = await schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPost(client, args361.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149616,9 +150102,9 @@ var init_schema3OtherRefreshRepositoriesApiV1SandboxGithubRepositoriesRefreshPos
 
 // src/funcs/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
 function schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, request, options) {
-  return new APIPromise($do369(client, request, options));
+  return new APIPromise($do370(client, request, options));
 }
-async function $do369(client, request, options) {
+async function $do370(client, request, options) {
   const parsed = safeParse4(request, (value) => ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149703,20 +150189,20 @@ var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost =
 });
 
 // src/mcp-server/tools/schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost.ts
-var args360, tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost;
+var args361, tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost;
 var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2 = __esm(() => {
   init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost();
   init_operations();
   init_tools();
-  args360 = {
+  args361 = {
     request: ResolveReferenceApiV1SandboxGithubRepositoriesResolvePostRequest$inboundSchema
   };
   tool$schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost = {
     name: "schema-3-other-resolve-reference-api-v1-sandbox-github-repositories-resolve-post",
     description: `Resolve Reference`,
-    args: args360,
-    tool: async (client, args361, ctx) => {
-      const [result, apiCall] = await schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, args361.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args361,
+    tool: async (client, args362, ctx) => {
+      const [result, apiCall] = await schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost(client, args362.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149731,9 +150217,9 @@ var init_schema3OtherResolveReferenceApiV1SandboxGithubRepositoriesResolvePost2
 
 // src/funcs/schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost.ts
 function schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost(client, request, options) {
-  return new APIPromise($do370(client, request, options));
+  return new APIPromise($do371(client, request, options));
 }
-async function $do370(client, request, options) {
+async function $do371(client, request, options) {
   const parsed = safeParse4(request, (value) => RunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPostRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149821,20 +150307,20 @@ var init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironment
 });
 
 // src/mcp-server/tools/schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost.ts
-var args361, tool$schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost;
+var args362, tool$schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost;
 var init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost2 = __esm(() => {
   init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost();
   init_operations();
   init_tools();
-  args361 = {
+  args362 = {
     request: RunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPostRequest$inboundSchema
   };
   tool$schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost = {
     name: "schema-3-other-run-environment-setup-api-v1-sandbox-sessions-session-id-environment-setup-post",
     description: `Run Environment Setup`,
-    args: args361,
-    tool: async (client, args362, ctx) => {
-      const [result, apiCall] = await schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost(client, args362.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args362,
+    tool: async (client, args363, ctx) => {
+      const [result, apiCall] = await schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironmentSetupPost(client, args363.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149849,9 +150335,9 @@ var init_schema3OtherRunEnvironmentSetupApiV1SandboxSessionsSessionIdEnvironment
 
 // src/funcs/schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut.ts
 function schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut(client, request, options) {
-  return new APIPromise($do371(client, request, options));
+  return new APIPromise($do372(client, request, options));
 }
-async function $do371(client, request, options) {
+async function $do372(client, request, options) {
   const parsed = safeParse4(request, (value) => UpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPutRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -149942,20 +150428,20 @@ var init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut =
 });
 
 // src/mcp-server/tools/schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut.ts
-var args362, tool$schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut;
+var args363, tool$schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut;
 var init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut2 = __esm(() => {
   init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut();
   init_operations();
   init_tools();
-  args362 = {
+  args363 = {
     request: UpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPutRequest$inboundSchema
   };
   tool$schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut = {
     name: "schema-3-other-update-environment-api-v1-sandbox-environments-environment-id-put",
     description: `Update Environment`,
-    args: args362,
-    tool: async (client, args363, ctx) => {
-      const [result, apiCall] = await schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut(client, args363.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args363,
+    tool: async (client, args364, ctx) => {
+      const [result, apiCall] = await schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut(client, args364.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -149970,9 +150456,9 @@ var init_schema3OtherUpdateEnvironmentApiV1SandboxEnvironmentsEnvironmentIdPut2
 
 // src/funcs/usageCosts.ts
 function usageCosts(client, request, options) {
-  return new APIPromise($do372(client, request, options));
+  return new APIPromise($do373(client, request, options));
 }
-async function $do372(client, request, options) {
+async function $do373(client, request, options) {
   const parsed = safeParse4(request, (value) => GetCostsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -150055,12 +150541,12 @@ var init_usageCosts = __esm(() => {
 });
 
 // src/mcp-server/tools/usageCosts.ts
-var args363, tool$usageCosts;
+var args364, tool$usageCosts;
 var init_usageCosts2 = __esm(() => {
   init_usageCosts();
   init_operations();
   init_tools();
-  args363 = {
+  args364 = {
     request: GetCostsRequest$inboundSchema
   };
   tool$usageCosts = {
@@ -150068,9 +150554,9 @@ var init_usageCosts2 = __esm(() => {
     description: `Aggregate cost by dimension
 
 Sums stored per-entry cost over [start_time, end_time), grouped by any of service, task_type, model, api_key_id, team_id, user_id, external_user_id, org_id. Point-in-time correct for chargeback/showback.`,
-    args: args363,
-    tool: async (client, args364, ctx) => {
-      const [result, apiCall] = await usageCosts(client, args364.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args364,
+    tool: async (client, args365, ctx) => {
+      const [result, apiCall] = await usageCosts(client, args365.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -150085,9 +150571,9 @@ Sums stored per-entry cost over [start_time, end_time), grouped by any of servic
 
 // src/funcs/usageSandbox.ts
 function usageSandbox(client, request, options) {
-  return new APIPromise($do373(client, request, options));
+  return new APIPromise($do374(client, request, options));
 }
-async function $do373(client, request, options) {
+async function $do374(client, request, options) {
   const parsed = safeParse4(request, (value) => GetSandboxUsageRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -150178,12 +150664,12 @@ var init_usageSandbox = __esm(() => {
 });
 
 // src/mcp-server/tools/usageSandbox.ts
-var args364, tool$usageSandbox;
+var args365, tool$usageSandbox;
 var init_usageSandbox2 = __esm(() => {
   init_usageSandbox();
   init_operations();
   init_tools();
-  args364 = {
+  args365 = {
     request: GetSandboxUsageRequest$inboundSchema
   };
   tool$usageSandbox = {
@@ -150191,9 +150677,9 @@ var init_usageSandbox2 = __esm(() => {
     description: `Get Sandbox Usage
 
 Aggregate sandbox usage (session lifecycle, execution, and workspace operations) over a time range, bucketed and optionally grouped. Buckets are calendar-aligned in UTC: \`start_time\` is snapped down and \`end_time\` snapped up to the nearest bucket-width boundary, so the first and last buckets may extend slightly beyond the requested range. Org-scoped: callers see their own usage, org admins their team's; cluster admins may pass \`all_orgs\` or \`org_ids\`. Cost and spend reporting lives in the budgeting API (\`/api/v1/budgeting/usage/costs\`).`,
-    args: args364,
-    tool: async (client, args365, ctx) => {
-      const [result, apiCall] = await usageSandbox(client, args365.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args365,
+    tool: async (client, args366, ctx) => {
+      const [result, apiCall] = await usageSandbox(client, args366.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -150210,7 +150696,7 @@ Aggregate sandbox usage (session lifecycle, execution, and workspace operations)
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.54.22"
+    version: "0.54.23"
   });
   const client = new SDKCore({
     bearerAuth: deps.bearerAuth,
@@ -150495,6 +150981,7 @@ function createMCPServer(deps) {
   tool(tool$llmPromptsListVersions);
   tool(tool$llmPromptsGetVersion);
   tool(tool$llmPromptsRollback);
+  tool(tool$llmResponsesCreate);
   tool(tool$llmResponsesList);
   tool(tool$llmResponsesGet);
   tool(tool$llmResponsesUpdate);
@@ -150878,6 +151365,7 @@ var init_server2 = __esm(() => {
   init_llmPromptsUpdate2();
   init_llmResponsesCancel2();
   init_llmResponsesCompact2();
+  init_llmResponsesCreate2();
   init_llmResponsesDelete2();
   init_llmResponsesGet2();
   init_llmResponsesList2();
@@ -152154,7 +152642,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.54.22"
+    currentVersion: "0.54.23"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -152162,5 +152650,5 @@ export {
   app
 };
 
-//# debugId=8ADCA6049B19E00D64756E2164756E21
+//# debugId=7E31D83C714BC24164756E2164756E21
 //# sourceMappingURL=mcp-server.js.map