@meetkai/mka1 0.54.92 → 0.54.94

package/src/mcp-server/tools/agentsListFunctionTools.ts

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { agentsListFunctionTools } from "../../funcs/agentsListFunctionTools.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.ListFunctionToolsRequest$inboundSchema,
+};
+
+export const tool$agentsListFunctionTools: ToolDefinition<typeof args> = {
+  name: "agents-list-function-tools",
+  description: `List reusable function tools`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await agentsListFunctionTools(
+      client,
+      args.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);
+  },
+};

package/src/mcp-server/tools/agentsRestoreAgent.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { agentsRestoreAgent } from "../../funcs/agentsRestoreAgent.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.RestoreAgentRequest$inboundSchema,
+};
+
+export const tool$agentsRestoreAgent: ToolDefinition<typeof args> = {
+  name: "agents-restore-agent",
+  description: `Restore a soft-deleted agent
+
+Restores the original configuration and history before retention_expires_at. Requires write:agents in the original mutation tenancy. Schedules remain paused.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await agentsRestoreAgent(
+      client,
+      args.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);
+  },
+};

package/src/mcp-server/tools/agentsUpdateFunctionTool.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { agentsUpdateFunctionTool } from "../../funcs/agentsUpdateFunctionTool.js";
+import * as operations from "../../models/operations/index.js";
+import { formatResult, ToolDefinition } from "../tools.js";
+
+const args = {
+  request: operations.UpdateFunctionToolRequest$inboundSchema,
+};
+
+export const tool$agentsUpdateFunctionTool: ToolDefinition<typeof args> = {
+  name: "agents-update-function-tool",
+  description: `Replace a reusable function definition
+
+Updates apply to every attached agent on its next run. Existing run snapshots are immutable.`,
+  args,
+  tool: async (client, args, ctx) => {
+    const [result, apiCall] = await agentsUpdateFunctionTool(
+      client,
+      args.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);
+  },
+};

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";