@meetkai/mka1 0.54.21 → 0.54.23

package/src/models/components/startexportfeedbackresponse.ts

@@ -3,6 +3,7 @@
  */
 
 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";
@@ -116,19 +117,26 @@ export const Progress$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   stage: Stage$inboundSchema,
-  recordCount: z.number().int().optional(),
-  completionCount: z.number().int().optional(),
-  responseCount: z.number().int().optional(),
-  parquetBytes: z.number().int().optional(),
+  record_count: z.number().int().optional(),
+  completion_count: z.number().int().optional(),
+  response_count: z.number().int().optional(),
+  parquet_bytes: z.number().int().optional(),
   message: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "record_count": "recordCount",
+    "completion_count": "completionCount",
+    "response_count": "responseCount",
+    "parquet_bytes": "parquetBytes",
+  });
 });
 /** @internal */
 export type Progress$Outbound = {
   stage: string;
-  recordCount?: number | undefined;
-  completionCount?: number | undefined;
-  responseCount?: number | undefined;
-  parquetBytes?: number | undefined;
+  record_count?: number | undefined;
+  completion_count?: number | undefined;
+  response_count?: number | undefined;
+  parquet_bytes?: number | undefined;
   message: string;
 };
 
@@ -144,6 +152,13 @@ export const Progress$outboundSchema: z.ZodType<
   responseCount: z.number().int().optional(),
   parquetBytes: z.number().int().optional(),
   message: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    recordCount: "record_count",
+    completionCount: "completion_count",
+    responseCount: "response_count",
+    parquetBytes: "parquet_bytes",
+  });
 });
 
 export function progressToJSON(progress: Progress): string {

package/src/models/components/updatefeedbackresponse.ts

@@ -3,6 +3,7 @@
  */
 
 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";
@@ -23,7 +24,7 @@ export type UpdateFeedbackResponseRating = ClosedEnum<
 >;
 
 /**
- * Response containing the updated feedback entry with new updatedAt timestamp.
+ * Response containing the updated feedback entry.
  */
 export type UpdateFeedbackResponse = {
   /**
@@ -39,11 +40,11 @@ export type UpdateFeedbackResponse = {
    */
   description?: string | undefined;
   /**
-   * Timestamp when the feedback was created
+   * ISO 8601 timestamp when the underlying output was created
    */
   createdAt?: Date | undefined;
   /**
-   * Timestamp when the feedback was last updated
+   * ISO 8601 timestamp when the underlying output record was last updated
    */
   updatedAt?: Date | undefined;
 };
@@ -66,18 +67,23 @@ export const UpdateFeedbackResponse$inboundSchema: z.ZodType<
   id: z.string(),
   rating: UpdateFeedbackResponseRating$inboundSchema.optional(),
   description: z.string().optional(),
-  createdAt: z.string().datetime({ offset: true }).transform(v => new Date(v))
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
-  updatedAt: z.string().datetime({ offset: true }).transform(v => new Date(v))
+  updated_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "created_at": "createdAt",
+    "updated_at": "updatedAt",
+  });
 });
 /** @internal */
 export type UpdateFeedbackResponse$Outbound = {
   id: string;
   rating?: string | undefined;
   description?: string | undefined;
-  createdAt?: string | undefined;
-  updatedAt?: string | undefined;
+  created_at?: string | undefined;
+  updated_at?: string | undefined;
 };
 
 /** @internal */
@@ -91,6 +97,11 @@ export const UpdateFeedbackResponse$outboundSchema: z.ZodType<
   description: z.string().optional(),
   createdAt: z.date().transform(v => v.toISOString()).optional(),
   updatedAt: z.date().transform(v => v.toISOString()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    createdAt: "created_at",
+    updatedAt: "updated_at",
+  });
 });
 
 export function updateFeedbackResponseToJSON(

package/src/models/operations/createresponse.ts

@@ -0,0 +1,198 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { EventStream } from "../../lib/event-streams.js";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreateResponseRequest = {
+  /**
+   * Optional external end-user identifier forwarded by the API gateway.
+   */
+  xOnBehalfOf?: string | undefined;
+  responsesCreateRequest: components.ResponsesCreateRequest;
+};
+
+/**
+ * Successful response - returns either streaming events (SSE) or a complete response object (JSON) depending on the stream parameter
+ */
+export type CreateResponseResponseBody = {
+  /**
+   * The event type (optional in SSE)
+   */
+  event?: string | undefined;
+  data: components.ResponseStreamingEvent;
+  /**
+   * Optional event ID for reconnection
+   */
+  id?: string | undefined;
+  /**
+   * Optional reconnection time in milliseconds
+   */
+  retry?: number | undefined;
+};
+
+export type CreateResponseResponse =
+  | components.ResponseObject
+  | EventStream<CreateResponseResponseBody>;
+
+/** @internal */
+export const CreateResponseRequest$inboundSchema: z.ZodType<
+  CreateResponseRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-On-Behalf-Of": z.string().optional(),
+  ResponsesCreateRequest: components.ResponsesCreateRequest$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "X-On-Behalf-Of": "xOnBehalfOf",
+    "ResponsesCreateRequest": "responsesCreateRequest",
+  });
+});
+/** @internal */
+export type CreateResponseRequest$Outbound = {
+  "X-On-Behalf-Of"?: string | undefined;
+  ResponsesCreateRequest: components.ResponsesCreateRequest$Outbound;
+};
+
+/** @internal */
+export const CreateResponseRequest$outboundSchema: z.ZodType<
+  CreateResponseRequest$Outbound,
+  z.ZodTypeDef,
+  CreateResponseRequest
+> = z.object({
+  xOnBehalfOf: z.string().optional(),
+  responsesCreateRequest: components.ResponsesCreateRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    xOnBehalfOf: "X-On-Behalf-Of",
+    responsesCreateRequest: "ResponsesCreateRequest",
+  });
+});
+
+export function createResponseRequestToJSON(
+  createResponseRequest: CreateResponseRequest,
+): string {
+  return JSON.stringify(
+    CreateResponseRequest$outboundSchema.parse(createResponseRequest),
+  );
+}
+export function createResponseRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateResponseRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateResponseRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateResponseRequest' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateResponseResponseBody$inboundSchema: z.ZodType<
+  CreateResponseResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  event: z.string().optional(),
+  data: z.unknown().transform((v, ctx) => {
+    if (typeof v !== "string") return v;
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(components.ResponseStreamingEvent$inboundSchema),
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
+/** @internal */
+export type CreateResponseResponseBody$Outbound = {
+  event?: string | undefined;
+  data: components.ResponseStreamingEvent$Outbound;
+  id?: string | undefined;
+  retry?: number | undefined;
+};
+
+/** @internal */
+export const CreateResponseResponseBody$outboundSchema: z.ZodType<
+  CreateResponseResponseBody$Outbound,
+  z.ZodTypeDef,
+  CreateResponseResponseBody
+> = z.object({
+  event: z.string().optional(),
+  data: components.ResponseStreamingEvent$outboundSchema,
+  id: z.string().optional(),
+  retry: z.number().int().optional(),
+});
+
+export function createResponseResponseBodyToJSON(
+  createResponseResponseBody: CreateResponseResponseBody,
+): string {
+  return JSON.stringify(
+    CreateResponseResponseBody$outboundSchema.parse(createResponseResponseBody),
+  );
+}
+export function createResponseResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateResponseResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateResponseResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateResponseResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateResponseResponse$inboundSchema: z.ZodType<
+  CreateResponseResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  components.ResponseObject$inboundSchema,
+  z.instanceof(ReadableStream<Uint8Array>)
+    .transform(stream => {
+      return new EventStream(stream, rawEvent => {
+        return {
+          done: false,
+          value: z.lazy(() => CreateResponseResponseBody$inboundSchema).parse(
+            rawEvent,
+          ),
+        };
+      });
+    }),
+]);
+/** @internal */
+export type CreateResponseResponse$Outbound =
+  | components.ResponseObject$Outbound
+  | never;
+
+/** @internal */
+export const CreateResponseResponse$outboundSchema: z.ZodType<
+  CreateResponseResponse$Outbound,
+  z.ZodTypeDef,
+  CreateResponseResponse
+> = z.union([components.ResponseObject$outboundSchema, z.never()]);
+
+export function createResponseResponseToJSON(
+  createResponseResponse: CreateResponseResponse,
+): string {
+  return JSON.stringify(
+    CreateResponseResponse$outboundSchema.parse(createResponseResponse),
+  );
+}
+export function createResponseResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateResponseResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateResponseResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateResponseResponse' from JSON`,
+  );
+}

package/src/models/operations/index.ts

@@ -57,6 +57,7 @@ export * from "./createorupdateapiv1sandboxsessionssessionidgithubpullrequestpos
 export * from "./createprompt.js";
 export * from "./createpromptversion.js";
 export * from "./createrepo.js";
+export * from "./createresponse.js";
 export * from "./createresponsefeedback.js";
 export * from "./createscopedapikey.js";
 export * from "./createservice.js";

package/src/react-query/index.ts

@@ -279,6 +279,7 @@ export * from "./llmPromptsRollback.js";
 export * from "./llmPromptsUpdate.js";
 export * from "./llmResponsesCancel.js";
 export * from "./llmResponsesCompact.js";
+export * from "./llmResponsesCreate.js";
 export * from "./llmResponsesDelete.js";
 export * from "./llmResponsesGet.js";
 export * from "./llmResponsesList.js";

package/src/react-query/llmResponsesCreate.ts

@@ -0,0 +1,113 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import {
+  MutationKey,
+  useMutation,
+  UseMutationResult,
+} from "@tanstack/react-query";
+import { SDKCore } from "../core.js";
+import {
+  CreateAcceptEnum,
+  llmResponsesCreate,
+} from "../funcs/llmResponsesCreate.js";
+import { combineSignals } from "../lib/primitives.js";
+import { RequestOptions } from "../lib/sdks.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/httpclienterrors.js";
+import { ResponseValidationError } from "../models/errors/responsevalidationerror.js";
+import { SDKError } from "../models/errors/sdkerror.js";
+import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { useSDKContext } from "./_context.js";
+import { MutationHookOptions } from "./_types.js";
+
+export { CreateAcceptEnum } from "../funcs/llmResponsesCreate.js";
+
+export type LlmResponsesCreateMutationVariables = {
+  request: operations.CreateResponseRequest;
+  options?: RequestOptions & { acceptHeaderOverride?: CreateAcceptEnum };
+};
+
+export type LlmResponsesCreateMutationData = operations.CreateResponseResponse;
+
+export type LlmResponsesCreateMutationError =
+  | SDKError
+  | ResponseValidationError
+  | ConnectionError
+  | RequestAbortedError
+  | RequestTimeoutError
+  | InvalidRequestError
+  | UnexpectedClientError
+  | SDKValidationError;
+
+/**
+ * Create an agent-powered response with tool support
+ *
+ * @remarks
+ * Creates a new AI agent response using advanced language models with autonomous tool usage capabilities.
+ */
+export function useLlmResponsesCreateMutation(
+  options?: MutationHookOptions<
+    LlmResponsesCreateMutationData,
+    LlmResponsesCreateMutationError,
+    LlmResponsesCreateMutationVariables
+  >,
+): UseMutationResult<
+  LlmResponsesCreateMutationData,
+  LlmResponsesCreateMutationError,
+  LlmResponsesCreateMutationVariables
+> {
+  const client = useSDKContext();
+  return useMutation({
+    ...buildLlmResponsesCreateMutation(client, options),
+    ...options,
+  });
+}
+
+export function mutationKeyLlmResponsesCreate(): MutationKey {
+  return ["@meetkai/mka1", "responses", "create"];
+}
+
+export function buildLlmResponsesCreateMutation(
+  client$: SDKCore,
+  hookOptions?: RequestOptions & { acceptHeaderOverride?: CreateAcceptEnum },
+): {
+  mutationKey: MutationKey;
+  mutationFn: (
+    variables: LlmResponsesCreateMutationVariables,
+  ) => Promise<LlmResponsesCreateMutationData>;
+} {
+  return {
+    mutationKey: mutationKeyLlmResponsesCreate(),
+    mutationFn: function llmResponsesCreateMutationFn({
+      request,
+      options,
+    }): Promise<LlmResponsesCreateMutationData> {
+      const mergedOptions = {
+        ...hookOptions,
+        ...options,
+        fetchOptions: {
+          ...hookOptions?.fetchOptions,
+          ...options?.fetchOptions,
+          signal: combineSignals(
+            hookOptions?.fetchOptions?.signal,
+            options?.fetchOptions?.signal,
+          ),
+        },
+      };
+      return unwrapAsync(llmResponsesCreate(
+        client$,
+        request,
+        mergedOptions,
+      ));
+    },
+  };
+}

package/src/sdk/responses.ts

@@ -4,6 +4,10 @@
 
 import { llmResponsesCancel } from "../funcs/llmResponsesCancel.js";
 import { llmResponsesCompact } from "../funcs/llmResponsesCompact.js";
+import {
+  CreateAcceptEnum,
+  llmResponsesCreate,
+} from "../funcs/llmResponsesCreate.js";
 import { llmResponsesDelete } from "../funcs/llmResponsesDelete.js";
 import { GetAcceptEnum, llmResponsesGet } from "../funcs/llmResponsesGet.js";
 import { llmResponsesList } from "../funcs/llmResponsesList.js";
@@ -15,9 +19,28 @@ import * as components from "../models/components/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 
+export { CreateAcceptEnum } from "../funcs/llmResponsesCreate.js";
+
 export { GetAcceptEnum } from "../funcs/llmResponsesGet.js";
 
 export class Responses extends ClientSDK {
+  /**
+   * Create an agent-powered response with tool support
+   *
+   * @remarks
+   * Creates a new AI agent response using advanced language models with autonomous tool usage capabilities.
+   */
+  async create(
+    request: operations.CreateResponseRequest,
+    options?: RequestOptions & { acceptHeaderOverride?: CreateAcceptEnum },
+  ): Promise<operations.CreateResponseResponse> {
+    return unwrapAsync(llmResponsesCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * List all responses with pagination
    *