@meetkai/mka1 0.54.93 → 0.54.95

package/src/models/components/agent.ts

@@ -56,6 +56,15 @@ export type Agent = {
   createdAt: Date;
   updatedAt: Date;
   deletedAt: Date | null;
+  retentionExpiresAt: Date | null;
+  /**
+   * Whether the deleted agent is within its pinned restoration deadline, independent of caller permission.
+   */
+  withinRestoreWindow: boolean;
+  /**
+   * Whether the current caller has restoration permission within the pinned deadline.
+   */
+  canRestore: boolean;
 };
 
 /** @internal */
@@ -91,6 +100,11 @@ export const Agent$inboundSchema: z.ZodType<Agent, z.ZodTypeDef, unknown> = z
     deleted_at: z.nullable(
       z.string().datetime({ offset: true }).transform(v => new Date(v)),
     ),
+    retention_expires_at: z.nullable(
+      z.string().datetime({ offset: true }).transform(v => new Date(v)),
+    ),
+    within_restore_window: z.boolean(),
+    can_restore: z.boolean(),
   }).transform((v) => {
     return remap$(v, {
       "tool_choice": "toolChoice",
@@ -99,6 +113,9 @@ export const Agent$inboundSchema: z.ZodType<Agent, z.ZodTypeDef, unknown> = z
       "created_at": "createdAt",
       "updated_at": "updatedAt",
       "deleted_at": "deletedAt",
+      "retention_expires_at": "retentionExpiresAt",
+      "within_restore_window": "withinRestoreWindow",
+      "can_restore": "canRestore",
     });
   });
 /** @internal */
@@ -120,6 +137,9 @@ export type Agent$Outbound = {
   created_at: string;
   updated_at: string;
   deleted_at: string | null;
+  retention_expires_at: string | null;
+  within_restore_window: boolean;
+  can_restore: boolean;
 };
 
 /** @internal */
@@ -145,6 +165,9 @@ export const Agent$outboundSchema: z.ZodType<
   createdAt: z.date().transform(v => v.toISOString()),
   updatedAt: z.date().transform(v => v.toISOString()),
   deletedAt: z.nullable(z.date().transform(v => v.toISOString())),
+  retentionExpiresAt: z.nullable(z.date().transform(v => v.toISOString())),
+  withinRestoreWindow: z.boolean(),
+  canRestore: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
     toolChoice: "tool_choice",
@@ -153,6 +176,9 @@ export const Agent$outboundSchema: z.ZodType<
     createdAt: "created_at",
     updatedAt: "updated_at",
     deletedAt: "deleted_at",
+    retentionExpiresAt: "retention_expires_at",
+    withinRestoreWindow: "within_restore_window",
+    canRestore: "can_restore",
   });
 });
 

package/src/models/components/agentsfunctiontooldefinition.ts

@@ -0,0 +1,99 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const AgentsFunctionToolDefinitionType = {
+  Function: "function",
+} as const;
+export type AgentsFunctionToolDefinitionType = ClosedEnum<
+  typeof AgentsFunctionToolDefinitionType
+>;
+
+export type AgentsFunctionToolDefinition = {
+  type: AgentsFunctionToolDefinitionType;
+  name: string;
+  description?: string | undefined;
+  parameters: { [k: string]: any };
+  strict?: boolean | undefined;
+  deferLoading?: boolean | undefined;
+};
+
+/** @internal */
+export const AgentsFunctionToolDefinitionType$inboundSchema: z.ZodNativeEnum<
+  typeof AgentsFunctionToolDefinitionType
+> = z.nativeEnum(AgentsFunctionToolDefinitionType);
+/** @internal */
+export const AgentsFunctionToolDefinitionType$outboundSchema: z.ZodNativeEnum<
+  typeof AgentsFunctionToolDefinitionType
+> = AgentsFunctionToolDefinitionType$inboundSchema;
+
+/** @internal */
+export const AgentsFunctionToolDefinition$inboundSchema: z.ZodType<
+  AgentsFunctionToolDefinition,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: AgentsFunctionToolDefinitionType$inboundSchema,
+  name: z.string(),
+  description: z.string().optional(),
+  parameters: z.record(z.any()),
+  strict: z.boolean().default(true),
+  defer_loading: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "defer_loading": "deferLoading",
+  });
+});
+/** @internal */
+export type AgentsFunctionToolDefinition$Outbound = {
+  type: string;
+  name: string;
+  description?: string | undefined;
+  parameters: { [k: string]: any };
+  strict: boolean;
+  defer_loading?: boolean | undefined;
+};
+
+/** @internal */
+export const AgentsFunctionToolDefinition$outboundSchema: z.ZodType<
+  AgentsFunctionToolDefinition$Outbound,
+  z.ZodTypeDef,
+  AgentsFunctionToolDefinition
+> = z.object({
+  type: AgentsFunctionToolDefinitionType$outboundSchema,
+  name: z.string(),
+  description: z.string().optional(),
+  parameters: z.record(z.any()),
+  strict: z.boolean().default(true),
+  deferLoading: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    deferLoading: "defer_loading",
+  });
+});
+
+export function agentsFunctionToolDefinitionToJSON(
+  agentsFunctionToolDefinition: AgentsFunctionToolDefinition,
+): string {
+  return JSON.stringify(
+    AgentsFunctionToolDefinition$outboundSchema.parse(
+      agentsFunctionToolDefinition,
+    ),
+  );
+}
+export function agentsFunctionToolDefinitionFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentsFunctionToolDefinition, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentsFunctionToolDefinition$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentsFunctionToolDefinition' from JSON`,
+  );
+}

package/src/models/components/functiontool.ts

@@ -0,0 +1,95 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AgentsFunctionToolDefinition,
+  AgentsFunctionToolDefinition$inboundSchema,
+  AgentsFunctionToolDefinition$Outbound,
+  AgentsFunctionToolDefinition$outboundSchema,
+} from "./agentsfunctiontooldefinition.js";
+
+export const FunctionToolObject = {
+  AgentFunctionTool: "agent.function_tool",
+} as const;
+export type FunctionToolObject = ClosedEnum<typeof FunctionToolObject>;
+
+export type FunctionTool = {
+  object: FunctionToolObject;
+  id: string;
+  definition: AgentsFunctionToolDefinition;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+/** @internal */
+export const FunctionToolObject$inboundSchema: z.ZodNativeEnum<
+  typeof FunctionToolObject
+> = z.nativeEnum(FunctionToolObject);
+/** @internal */
+export const FunctionToolObject$outboundSchema: z.ZodNativeEnum<
+  typeof FunctionToolObject
+> = FunctionToolObject$inboundSchema;
+
+/** @internal */
+export const FunctionTool$inboundSchema: z.ZodType<
+  FunctionTool,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: FunctionToolObject$inboundSchema,
+  id: z.string(),
+  definition: AgentsFunctionToolDefinition$inboundSchema,
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+  });
+});
+/** @internal */
+export type FunctionTool$Outbound = {
+  object: string;
+  id: string;
+  definition: AgentsFunctionToolDefinition$Outbound;
+  created_at: string;
+  updated_at: string;
+};
+
+/** @internal */
+export const FunctionTool$outboundSchema: z.ZodType<
+  FunctionTool$Outbound,
+  z.ZodTypeDef,
+  FunctionTool
+> = z.object({
+  object: FunctionToolObject$outboundSchema,
+  id: z.string(),
+  definition: AgentsFunctionToolDefinition$outboundSchema,
+  createdAt: z.date().transform(v => v.toISOString()),
+  updatedAt: z.date().transform(v => v.toISOString()),
+}).transform((v) => {
+  return remap$(v, {
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+  });
+});
+
+export function functionToolToJSON(functionTool: FunctionTool): string {
+  return JSON.stringify(FunctionTool$outboundSchema.parse(functionTool));
+}
+export function functionToolFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionTool, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionTool$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionTool' from JSON`,
+  );
+}

package/src/models/components/functiontoollist.ts

@@ -0,0 +1,101 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  FunctionTool,
+  FunctionTool$inboundSchema,
+  FunctionTool$Outbound,
+  FunctionTool$outboundSchema,
+} from "./functiontool.js";
+
+export const FunctionToolListObject = {
+  List: "list",
+} as const;
+export type FunctionToolListObject = ClosedEnum<typeof FunctionToolListObject>;
+
+export type FunctionToolList = {
+  object: FunctionToolListObject;
+  data: Array<FunctionTool>;
+  firstId: string | null;
+  lastId: string | null;
+  hasMore: boolean;
+};
+
+/** @internal */
+export const FunctionToolListObject$inboundSchema: z.ZodNativeEnum<
+  typeof FunctionToolListObject
+> = z.nativeEnum(FunctionToolListObject);
+/** @internal */
+export const FunctionToolListObject$outboundSchema: z.ZodNativeEnum<
+  typeof FunctionToolListObject
+> = FunctionToolListObject$inboundSchema;
+
+/** @internal */
+export const FunctionToolList$inboundSchema: z.ZodType<
+  FunctionToolList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: FunctionToolListObject$inboundSchema,
+  data: z.array(FunctionTool$inboundSchema),
+  first_id: z.nullable(z.string()),
+  last_id: z.nullable(z.string()),
+  has_more: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    "first_id": "firstId",
+    "last_id": "lastId",
+    "has_more": "hasMore",
+  });
+});
+/** @internal */
+export type FunctionToolList$Outbound = {
+  object: string;
+  data: Array<FunctionTool$Outbound>;
+  first_id: string | null;
+  last_id: string | null;
+  has_more: boolean;
+};
+
+/** @internal */
+export const FunctionToolList$outboundSchema: z.ZodType<
+  FunctionToolList$Outbound,
+  z.ZodTypeDef,
+  FunctionToolList
+> = z.object({
+  object: FunctionToolListObject$outboundSchema,
+  data: z.array(FunctionTool$outboundSchema),
+  firstId: z.nullable(z.string()),
+  lastId: z.nullable(z.string()),
+  hasMore: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    firstId: "first_id",
+    lastId: "last_id",
+    hasMore: "has_more",
+  });
+});
+
+export function functionToolListToJSON(
+  functionToolList: FunctionToolList,
+): string {
+  return JSON.stringify(
+    FunctionToolList$outboundSchema.parse(functionToolList),
+  );
+}
+export function functionToolListFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionToolList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionToolList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionToolList' from JSON`,
+  );
+}

package/src/models/components/functiontoolreference.ts

@@ -0,0 +1,81 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const FunctionToolReferenceType = {
+  FunctionReference: "function_reference",
+} as const;
+export type FunctionToolReferenceType = ClosedEnum<
+  typeof FunctionToolReferenceType
+>;
+
+export type FunctionToolReference = {
+  type: FunctionToolReferenceType;
+  functionToolId: string;
+};
+
+/** @internal */
+export const FunctionToolReferenceType$inboundSchema: z.ZodNativeEnum<
+  typeof FunctionToolReferenceType
+> = z.nativeEnum(FunctionToolReferenceType);
+/** @internal */
+export const FunctionToolReferenceType$outboundSchema: z.ZodNativeEnum<
+  typeof FunctionToolReferenceType
+> = FunctionToolReferenceType$inboundSchema;
+
+/** @internal */
+export const FunctionToolReference$inboundSchema: z.ZodType<
+  FunctionToolReference,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: FunctionToolReferenceType$inboundSchema,
+  function_tool_id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "function_tool_id": "functionToolId",
+  });
+});
+/** @internal */
+export type FunctionToolReference$Outbound = {
+  type: string;
+  function_tool_id: string;
+};
+
+/** @internal */
+export const FunctionToolReference$outboundSchema: z.ZodType<
+  FunctionToolReference$Outbound,
+  z.ZodTypeDef,
+  FunctionToolReference
+> = z.object({
+  type: FunctionToolReferenceType$outboundSchema,
+  functionToolId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    functionToolId: "function_tool_id",
+  });
+});
+
+export function functionToolReferenceToJSON(
+  functionToolReference: FunctionToolReference,
+): string {
+  return JSON.stringify(
+    FunctionToolReference$outboundSchema.parse(functionToolReference),
+  );
+}
+export function functionToolReferenceFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionToolReference, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionToolReference$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionToolReference' from JSON`,
+  );
+}

package/src/models/components/index.ts

@@ -24,6 +24,7 @@ export * from "./agentrunwake.js";
 export * from "./agentschedule.js";
 export * from "./agentschedulelist.js";
 export * from "./agentschedulespec.js";
+export * from "./agentsfunctiontooldefinition.js";
 export * from "./agenttextconfiguration.js";
 export * from "./agentversion.js";
 export * from "./agentversionlist.js";
@@ -363,12 +364,15 @@ export * from "./finetuningjob.js";
 export * from "./formatdetail.js";
 export * from "./formatlist.js";
 export * from "./formatsummary.js";
+export * from "./functiontool.js";
 export * from "./functiontoolcall.js";
 export * from "./functiontoolcalloutput.js";
 export * from "./functiontoolcalloutputwithid.js";
 export * from "./functiontoolcallwithid.js";
 export * from "./functiontoolchoice.js";
 export * from "./functiontooldefinition.js";
+export * from "./functiontoollist.js";
+export * from "./functiontoolreference.js";
 export * from "./generation.js";
 export * from "./generationcreated.js";
 export * from "./generationmodelusage.js";

package/src/models/components/openaichatcompletion.ts

@@ -84,6 +84,14 @@ export type OpenAIChatCompletion = {
    * This fingerprint represents the backend configuration that the model runs with. Can be used in conjunction with the seed request parameter to understand when backend changes have been made that might impact determinism.
    */
   systemFingerprint?: string | undefined;
+  /**
+   * The concrete catalog model that served the completion, after resolving aliases such as "auto" and any failover.
+   */
+  resolvedModel?: string | undefined;
+  /**
+   * The registry provider key of the model named by resolved_model: the provider that actually served the completion.
+   */
+  resolvedProvider?: string | undefined;
 };
 
 /** @internal */
@@ -230,9 +238,13 @@ export const OpenAIChatCompletion$inboundSchema: z.ZodType<
   choices: z.array(OpenAIChatCompletionChoice$inboundSchema),
   usage: z.lazy(() => OpenAIChatCompletionUsage1$inboundSchema),
   system_fingerprint: z.string().optional(),
+  resolved_model: z.string().optional(),
+  resolved_provider: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     "system_fingerprint": "systemFingerprint",
+    "resolved_model": "resolvedModel",
+    "resolved_provider": "resolvedProvider",
   });
 });
 /** @internal */
@@ -244,6 +256,8 @@ export type OpenAIChatCompletion$Outbound = {
   choices: Array<OpenAIChatCompletionChoice$Outbound>;
   usage: OpenAIChatCompletionUsage1$Outbound;
   system_fingerprint?: string | undefined;
+  resolved_model?: string | undefined;
+  resolved_provider?: string | undefined;
 };
 
 /** @internal */
@@ -259,9 +273,13 @@ export const OpenAIChatCompletion$outboundSchema: z.ZodType<
   choices: z.array(OpenAIChatCompletionChoice$outboundSchema),
   usage: z.lazy(() => OpenAIChatCompletionUsage1$outboundSchema),
   systemFingerprint: z.string().optional(),
+  resolvedModel: z.string().optional(),
+  resolvedProvider: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     systemFingerprint: "system_fingerprint",
+    resolvedModel: "resolved_model",
+    resolvedProvider: "resolved_provider",
   });
 });
 

package/src/models/components/openaichatcompletionchunk.ts

@@ -321,6 +321,14 @@ export type OpenAIChatCompletionChunk = {
    * This fingerprint represents the backend configuration that the model runs with
    */
   systemFingerprint?: string | undefined;
+  /**
+   * The concrete catalog model that served the completion, after resolving aliases such as "auto" and any failover.
+   */
+  resolvedModel?: string | undefined;
+  /**
+   * The registry provider key of the model named by resolved_model: the provider that actually served the completion.
+   */
+  resolvedProvider?: string | undefined;
 };
 
 /** @internal */
@@ -1241,9 +1249,13 @@ export const OpenAIChatCompletionChunk$inboundSchema: z.ZodType<
   choices: z.array(z.lazy(() => Choices$inboundSchema)),
   usage: OpenAIChatCompletionUsage$inboundSchema.optional(),
   system_fingerprint: z.string().optional(),
+  resolved_model: z.string().optional(),
+  resolved_provider: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     "system_fingerprint": "systemFingerprint",
+    "resolved_model": "resolvedModel",
+    "resolved_provider": "resolvedProvider",
   });
 });
 /** @internal */
@@ -1255,6 +1267,8 @@ export type OpenAIChatCompletionChunk$Outbound = {
   choices: Array<Choices$Outbound>;
   usage?: OpenAIChatCompletionUsage$Outbound | undefined;
   system_fingerprint?: string | undefined;
+  resolved_model?: string | undefined;
+  resolved_provider?: string | undefined;
 };
 
 /** @internal */
@@ -1270,9 +1284,13 @@ export const OpenAIChatCompletionChunk$outboundSchema: z.ZodType<
   choices: z.array(z.lazy(() => Choices$outboundSchema)),
   usage: OpenAIChatCompletionUsage$outboundSchema.optional(),
   systemFingerprint: z.string().optional(),
+  resolvedModel: z.string().optional(),
+  resolvedProvider: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
     systemFingerprint: "system_fingerprint",
+    resolvedModel: "resolved_model",
+    resolvedProvider: "resolved_provider",
   });
 });
 

package/src/models/components/responseobject.ts

@@ -298,6 +298,10 @@ export type ResponseObject = {
    * The concrete catalog model selected after resolving aliases such as "auto".
    */
   resolvedModel?: string | undefined;
+  /**
+   * The registry provider key of the model named by resolved_model: the provider that actually served the response, including after a failover. Absent until a route is known.
+   */
+  resolvedProvider?: string | undefined;
   output: Array<Item>;
   outputText?: string | undefined;
   parallelToolCalls: boolean;
@@ -850,6 +854,7 @@ export const ResponseObject$inboundSchema: z.ZodType<
   metadata: z.record(z.string()),
   model: z.string(),
   resolved_model: z.string().optional(),
+  resolved_provider: z.string().optional(),
   output: z.array(Item$inboundSchema),
   output_text: z.string().optional(),
   parallel_tool_calls: z.boolean(),
@@ -900,6 +905,7 @@ export const ResponseObject$inboundSchema: z.ZodType<
     "max_output_tokens": "maxOutputTokens",
     "max_tool_calls": "maxToolCalls",
     "resolved_model": "resolvedModel",
+    "resolved_provider": "resolvedProvider",
     "output_text": "outputText",
     "parallel_tool_calls": "parallelToolCalls",
     "previous_response_id": "previousResponseId",
@@ -931,6 +937,7 @@ export type ResponseObject$Outbound = {
   metadata: { [k: string]: string };
   model: string;
   resolved_model?: string | undefined;
+  resolved_provider?: string | undefined;
   output: Array<Item$Outbound>;
   output_text?: string | undefined;
   parallel_tool_calls: boolean;
@@ -992,6 +999,7 @@ export const ResponseObject$outboundSchema: z.ZodType<
   metadata: z.record(z.string()),
   model: z.string(),
   resolvedModel: z.string().optional(),
+  resolvedProvider: z.string().optional(),
   output: z.array(Item$outboundSchema),
   outputText: z.string().optional(),
   parallelToolCalls: z.boolean(),
@@ -1042,6 +1050,7 @@ export const ResponseObject$outboundSchema: z.ZodType<
     maxOutputTokens: "max_output_tokens",
     maxToolCalls: "max_tool_calls",
     resolvedModel: "resolved_model",
+    resolvedProvider: "resolved_provider",
     outputText: "output_text",
     parallelToolCalls: "parallel_tool_calls",
     previousResponseId: "previous_response_id",