@meetkai/mka1 0.48.24 → 0.48.25

package/src/models/components/agent.ts

@@ -52,6 +52,10 @@ export type Agent = {
   text: AgentTextConfiguration | null;
   reasoning: AgentReasoningConfiguration | null;
   metadata: { [k: string]: string };
+  /**
+   * Current configuration version. Incremented on every update or rollback.
+   */
+  version: number;
   createdAt: Date;
   updatedAt: Date;
   deletedAt: Date | null;
@@ -80,6 +84,7 @@ export const Agent$inboundSchema: z.ZodType<Agent, z.ZodTypeDef, unknown> = z
     text: z.nullable(AgentTextConfiguration$inboundSchema),
     reasoning: z.nullable(AgentReasoningConfiguration$inboundSchema),
     metadata: z.record(z.string()),
+    version: z.number().int(),
     created_at: z.string().datetime({ offset: true }).transform(v =>
       new Date(v)
     ),
@@ -114,6 +119,7 @@ export type Agent$Outbound = {
   text: AgentTextConfiguration$Outbound | null;
   reasoning: AgentReasoningConfiguration$Outbound | null;
   metadata: { [k: string]: string };
+  version: number;
   created_at: string;
   updated_at: string;
   deleted_at: string | null;
@@ -138,6 +144,7 @@ export const Agent$outboundSchema: z.ZodType<
   text: z.nullable(AgentTextConfiguration$outboundSchema),
   reasoning: z.nullable(AgentReasoningConfiguration$outboundSchema),
   metadata: z.record(z.string()),
+  version: z.number().int(),
   createdAt: z.date().transform(v => v.toISOString()),
   updatedAt: z.date().transform(v => v.toISOString()),
   deletedAt: z.nullable(z.date().transform(v => v.toISOString())),

package/src/models/components/agentrun.ts

@@ -31,6 +31,10 @@ export type AgentRun = {
   object: AgentRunObject;
   id: string;
   agentId: string;
+  /**
+   * The agent configuration version this run executed against. Null for runs created before versioning.
+   */
+  agentVersion: number | null;
   status: AgentRunStatus;
   input: JsonValue | null;
   conversation: JsonValue | null;
@@ -70,6 +74,7 @@ export const AgentRun$inboundSchema: z.ZodType<
   object: AgentRunObject$inboundSchema,
   id: z.string(),
   agent_id: z.string(),
+  agent_version: z.nullable(z.number().int()),
   status: AgentRunStatus$inboundSchema,
   input: z.nullable(JsonValue$inboundSchema),
   conversation: z.nullable(JsonValue$inboundSchema),
@@ -85,6 +90,7 @@ export const AgentRun$inboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     "agent_id": "agentId",
+    "agent_version": "agentVersion",
     "previous_response_id": "previousResponseId",
     "gateway_response_id": "gatewayResponseId",
     "gateway_response": "gatewayResponse",
@@ -97,6 +103,7 @@ export type AgentRun$Outbound = {
   object: string;
   id: string;
   agent_id: string;
+  agent_version: number | null;
   status: string;
   input: JsonValue$Outbound | null;
   conversation: JsonValue$Outbound | null;
@@ -118,6 +125,7 @@ export const AgentRun$outboundSchema: z.ZodType<
   object: AgentRunObject$outboundSchema,
   id: z.string(),
   agentId: z.string(),
+  agentVersion: z.nullable(z.number().int()),
   status: AgentRunStatus$outboundSchema,
   input: z.nullable(JsonValue$outboundSchema),
   conversation: z.nullable(JsonValue$outboundSchema),
@@ -131,6 +139,7 @@ export const AgentRun$outboundSchema: z.ZodType<
 }).transform((v) => {
   return remap$(v, {
     agentId: "agent_id",
+    agentVersion: "agent_version",
     previousResponseId: "previous_response_id",
     gatewayResponseId: "gateway_response_id",
     gatewayResponse: "gateway_response",

package/src/models/components/agentversion.ts

@@ -0,0 +1,181 @@
+/*
+ * 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 {
+  AgentReasoningConfiguration,
+  AgentReasoningConfiguration$inboundSchema,
+  AgentReasoningConfiguration$Outbound,
+  AgentReasoningConfiguration$outboundSchema,
+} from "./agentreasoningconfiguration.js";
+import {
+  AgentTextConfiguration,
+  AgentTextConfiguration$inboundSchema,
+  AgentTextConfiguration$Outbound,
+  AgentTextConfiguration$outboundSchema,
+} from "./agenttextconfiguration.js";
+import {
+  JsonValue,
+  JsonValue$inboundSchema,
+  JsonValue$Outbound,
+  JsonValue$outboundSchema,
+} from "./jsonvalue.js";
+import {
+  ToolDefinition,
+  ToolDefinition$inboundSchema,
+  ToolDefinition$Outbound,
+  ToolDefinition$outboundSchema,
+} from "./tooldefinition.js";
+
+export const AgentVersionObject = {
+  AgentVersion: "agent.version",
+} as const;
+export type AgentVersionObject = ClosedEnum<typeof AgentVersionObject>;
+
+export type AgentVersion = {
+  object: AgentVersionObject;
+  id: string;
+  agentId: string;
+  version: number;
+  /**
+   * True when this version matches the agent's current configuration.
+   */
+  isCurrent: boolean;
+  /**
+   * When this version was produced by a rollback, the version it was restored from.
+   */
+  restoredFromVersion: number | null;
+  name: string;
+  description: string | null;
+  model: string;
+  instructions: string | null;
+  tools: Array<ToolDefinition>;
+  toolChoice: JsonValue | null;
+  parallelToolCalls: boolean;
+  maxToolCalls: number | null;
+  text: AgentTextConfiguration | null;
+  reasoning: AgentReasoningConfiguration | null;
+  metadata: { [k: string]: string };
+  createdAt: Date;
+};
+
+/** @internal */
+export const AgentVersionObject$inboundSchema: z.ZodNativeEnum<
+  typeof AgentVersionObject
+> = z.nativeEnum(AgentVersionObject);
+/** @internal */
+export const AgentVersionObject$outboundSchema: z.ZodNativeEnum<
+  typeof AgentVersionObject
+> = AgentVersionObject$inboundSchema;
+
+/** @internal */
+export const AgentVersion$inboundSchema: z.ZodType<
+  AgentVersion,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: AgentVersionObject$inboundSchema,
+  id: z.string(),
+  agent_id: z.string(),
+  version: z.number().int(),
+  is_current: z.boolean(),
+  restored_from_version: z.nullable(z.number().int()),
+  name: z.string(),
+  description: z.nullable(z.string()),
+  model: z.string(),
+  instructions: z.nullable(z.string()),
+  tools: z.array(ToolDefinition$inboundSchema),
+  tool_choice: z.nullable(JsonValue$inboundSchema),
+  parallel_tool_calls: z.boolean(),
+  max_tool_calls: z.nullable(z.number().int()),
+  text: z.nullable(AgentTextConfiguration$inboundSchema),
+  reasoning: z.nullable(AgentReasoningConfiguration$inboundSchema),
+  metadata: z.record(z.string()),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+}).transform((v) => {
+  return remap$(v, {
+    "agent_id": "agentId",
+    "is_current": "isCurrent",
+    "restored_from_version": "restoredFromVersion",
+    "tool_choice": "toolChoice",
+    "parallel_tool_calls": "parallelToolCalls",
+    "max_tool_calls": "maxToolCalls",
+    "created_at": "createdAt",
+  });
+});
+/** @internal */
+export type AgentVersion$Outbound = {
+  object: string;
+  id: string;
+  agent_id: string;
+  version: number;
+  is_current: boolean;
+  restored_from_version: number | null;
+  name: string;
+  description: string | null;
+  model: string;
+  instructions: string | null;
+  tools: Array<ToolDefinition$Outbound>;
+  tool_choice: JsonValue$Outbound | null;
+  parallel_tool_calls: boolean;
+  max_tool_calls: number | null;
+  text: AgentTextConfiguration$Outbound | null;
+  reasoning: AgentReasoningConfiguration$Outbound | null;
+  metadata: { [k: string]: string };
+  created_at: string;
+};
+
+/** @internal */
+export const AgentVersion$outboundSchema: z.ZodType<
+  AgentVersion$Outbound,
+  z.ZodTypeDef,
+  AgentVersion
+> = z.object({
+  object: AgentVersionObject$outboundSchema,
+  id: z.string(),
+  agentId: z.string(),
+  version: z.number().int(),
+  isCurrent: z.boolean(),
+  restoredFromVersion: z.nullable(z.number().int()),
+  name: z.string(),
+  description: z.nullable(z.string()),
+  model: z.string(),
+  instructions: z.nullable(z.string()),
+  tools: z.array(ToolDefinition$outboundSchema),
+  toolChoice: z.nullable(JsonValue$outboundSchema),
+  parallelToolCalls: z.boolean(),
+  maxToolCalls: z.nullable(z.number().int()),
+  text: z.nullable(AgentTextConfiguration$outboundSchema),
+  reasoning: z.nullable(AgentReasoningConfiguration$outboundSchema),
+  metadata: z.record(z.string()),
+  createdAt: z.date().transform(v => v.toISOString()),
+}).transform((v) => {
+  return remap$(v, {
+    agentId: "agent_id",
+    isCurrent: "is_current",
+    restoredFromVersion: "restored_from_version",
+    toolChoice: "tool_choice",
+    parallelToolCalls: "parallel_tool_calls",
+    maxToolCalls: "max_tool_calls",
+    createdAt: "created_at",
+  });
+});
+
+export function agentVersionToJSON(agentVersion: AgentVersion): string {
+  return JSON.stringify(AgentVersion$outboundSchema.parse(agentVersion));
+}
+export function agentVersionFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentVersion, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentVersion$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentVersion' from JSON`,
+  );
+}

package/src/models/components/agentversionlist.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 {
+  AgentVersion,
+  AgentVersion$inboundSchema,
+  AgentVersion$Outbound,
+  AgentVersion$outboundSchema,
+} from "./agentversion.js";
+
+export const AgentVersionListObject = {
+  List: "list",
+} as const;
+export type AgentVersionListObject = ClosedEnum<typeof AgentVersionListObject>;
+
+export type AgentVersionList = {
+  object: AgentVersionListObject;
+  data: Array<AgentVersion>;
+  firstId: string | null;
+  lastId: string | null;
+  hasMore: boolean;
+};
+
+/** @internal */
+export const AgentVersionListObject$inboundSchema: z.ZodNativeEnum<
+  typeof AgentVersionListObject
+> = z.nativeEnum(AgentVersionListObject);
+/** @internal */
+export const AgentVersionListObject$outboundSchema: z.ZodNativeEnum<
+  typeof AgentVersionListObject
+> = AgentVersionListObject$inboundSchema;
+
+/** @internal */
+export const AgentVersionList$inboundSchema: z.ZodType<
+  AgentVersionList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: AgentVersionListObject$inboundSchema,
+  data: z.array(AgentVersion$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 AgentVersionList$Outbound = {
+  object: string;
+  data: Array<AgentVersion$Outbound>;
+  first_id: string | null;
+  last_id: string | null;
+  has_more: boolean;
+};
+
+/** @internal */
+export const AgentVersionList$outboundSchema: z.ZodType<
+  AgentVersionList$Outbound,
+  z.ZodTypeDef,
+  AgentVersionList
+> = z.object({
+  object: AgentVersionListObject$outboundSchema,
+  data: z.array(AgentVersion$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 agentVersionListToJSON(
+  agentVersionList: AgentVersionList,
+): string {
+  return JSON.stringify(
+    AgentVersionList$outboundSchema.parse(agentVersionList),
+  );
+}
+export function agentVersionListFromJSON(
+  jsonString: string,
+): SafeParseResult<AgentVersionList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AgentVersionList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AgentVersionList' from JSON`,
+  );
+}

package/src/models/components/createevalschedulerequest.ts

@@ -0,0 +1,150 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  EvalScheduleOverlapPolicy,
+  EvalScheduleOverlapPolicy$inboundSchema,
+  EvalScheduleOverlapPolicy$outboundSchema,
+} from "./evalscheduleoverlappolicy.js";
+import {
+  EvalScheduleRunConfig,
+  EvalScheduleRunConfig$inboundSchema,
+  EvalScheduleRunConfig$Outbound,
+  EvalScheduleRunConfig$outboundSchema,
+} from "./evalschedulerunconfig.js";
+
+export type CreateEvalScheduleRequest = {
+  name: string;
+  description?: string | undefined;
+  suiteId: string;
+  /**
+   * Pin a suite version. Omit to resolve the active version on each fire.
+   */
+  suiteVersion?: number | undefined;
+  /**
+   * 5-field cron expression. Provide exactly one of cron or interval_seconds.
+   */
+  cron?: string | undefined;
+  /**
+   * Fixed interval between fires, in seconds. Provide exactly one of cron or interval_seconds.
+   */
+  intervalSeconds?: number | undefined;
+  /**
+   * IANA timezone applied to cron expressions, for example US/Pacific.
+   */
+  timezone?: string | undefined;
+  overlapPolicy?: EvalScheduleOverlapPolicy | undefined;
+  /**
+   * When false, the schedule is created paused.
+   */
+  enabled?: boolean | undefined;
+  /**
+   * HTTPS endpoint notified of run status transitions.
+   */
+  webhookUrl?: string | undefined;
+  /**
+   * Secret used to HMAC-SHA256 sign webhook payloads.
+   */
+  webhookSecret?: string | undefined;
+  run: EvalScheduleRunConfig;
+  metadata?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const CreateEvalScheduleRequest$inboundSchema: z.ZodType<
+  CreateEvalScheduleRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  suite_id: z.string(),
+  suite_version: z.number().int().optional(),
+  cron: z.string().optional(),
+  interval_seconds: z.number().int().optional(),
+  timezone: z.string().default("UTC"),
+  overlap_policy: EvalScheduleOverlapPolicy$inboundSchema.optional(),
+  enabled: z.boolean().default(true),
+  webhook_url: z.string().optional(),
+  webhook_secret: z.string().optional(),
+  run: EvalScheduleRunConfig$inboundSchema,
+  metadata: z.record(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "suite_id": "suiteId",
+    "suite_version": "suiteVersion",
+    "interval_seconds": "intervalSeconds",
+    "overlap_policy": "overlapPolicy",
+    "webhook_url": "webhookUrl",
+    "webhook_secret": "webhookSecret",
+  });
+});
+/** @internal */
+export type CreateEvalScheduleRequest$Outbound = {
+  name: string;
+  description?: string | undefined;
+  suite_id: string;
+  suite_version?: number | undefined;
+  cron?: string | undefined;
+  interval_seconds?: number | undefined;
+  timezone: string;
+  overlap_policy?: string | undefined;
+  enabled: boolean;
+  webhook_url?: string | undefined;
+  webhook_secret?: string | undefined;
+  run: EvalScheduleRunConfig$Outbound;
+  metadata?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const CreateEvalScheduleRequest$outboundSchema: z.ZodType<
+  CreateEvalScheduleRequest$Outbound,
+  z.ZodTypeDef,
+  CreateEvalScheduleRequest
+> = z.object({
+  name: z.string(),
+  description: z.string().optional(),
+  suiteId: z.string(),
+  suiteVersion: z.number().int().optional(),
+  cron: z.string().optional(),
+  intervalSeconds: z.number().int().optional(),
+  timezone: z.string().default("UTC"),
+  overlapPolicy: EvalScheduleOverlapPolicy$outboundSchema.optional(),
+  enabled: z.boolean().default(true),
+  webhookUrl: z.string().optional(),
+  webhookSecret: z.string().optional(),
+  run: EvalScheduleRunConfig$outboundSchema,
+  metadata: z.record(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    suiteId: "suite_id",
+    suiteVersion: "suite_version",
+    intervalSeconds: "interval_seconds",
+    overlapPolicy: "overlap_policy",
+    webhookUrl: "webhook_url",
+    webhookSecret: "webhook_secret",
+  });
+});
+
+export function createEvalScheduleRequestToJSON(
+  createEvalScheduleRequest: CreateEvalScheduleRequest,
+): string {
+  return JSON.stringify(
+    CreateEvalScheduleRequest$outboundSchema.parse(createEvalScheduleRequest),
+  );
+}
+export function createEvalScheduleRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateEvalScheduleRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateEvalScheduleRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateEvalScheduleRequest' from JSON`,
+  );
+}

package/src/models/components/evalscheduledeletedobject.ts

@@ -0,0 +1,59 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type EvalScheduleDeletedObject = {
+  id: string;
+  object: "eval.schedule.deleted";
+  deleted: boolean;
+};
+
+/** @internal */
+export const EvalScheduleDeletedObject$inboundSchema: z.ZodType<
+  EvalScheduleDeletedObject,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  object: z.literal("eval.schedule.deleted"),
+  deleted: z.boolean(),
+});
+/** @internal */
+export type EvalScheduleDeletedObject$Outbound = {
+  id: string;
+  object: "eval.schedule.deleted";
+  deleted: boolean;
+};
+
+/** @internal */
+export const EvalScheduleDeletedObject$outboundSchema: z.ZodType<
+  EvalScheduleDeletedObject$Outbound,
+  z.ZodTypeDef,
+  EvalScheduleDeletedObject
+> = z.object({
+  id: z.string(),
+  object: z.literal("eval.schedule.deleted"),
+  deleted: z.boolean(),
+});
+
+export function evalScheduleDeletedObjectToJSON(
+  evalScheduleDeletedObject: EvalScheduleDeletedObject,
+): string {
+  return JSON.stringify(
+    EvalScheduleDeletedObject$outboundSchema.parse(evalScheduleDeletedObject),
+  );
+}
+export function evalScheduleDeletedObjectFromJSON(
+  jsonString: string,
+): SafeParseResult<EvalScheduleDeletedObject, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EvalScheduleDeletedObject$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EvalScheduleDeletedObject' from JSON`,
+  );
+}

package/src/models/components/evalscheduleoverlappolicy.ts

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const EvalScheduleOverlapPolicy = {
+  Skip: "skip",
+  BufferOne: "buffer_one",
+  AllowAll: "allow_all",
+} as const;
+export type EvalScheduleOverlapPolicy = ClosedEnum<
+  typeof EvalScheduleOverlapPolicy
+>;
+
+/** @internal */
+export const EvalScheduleOverlapPolicy$inboundSchema: z.ZodNativeEnum<
+  typeof EvalScheduleOverlapPolicy
+> = z.nativeEnum(EvalScheduleOverlapPolicy);
+/** @internal */
+export const EvalScheduleOverlapPolicy$outboundSchema: z.ZodNativeEnum<
+  typeof EvalScheduleOverlapPolicy
+> = EvalScheduleOverlapPolicy$inboundSchema;