@compose-market/sdk 0.5.1 → 0.6.2

package/generated/{agentic/src/models/operations/memory-transcript-get.ts → memory/src/models/operations/transcript-get.ts}

@@ -9,6 +9,7 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
 
 export const Type = {
   SessionId: "sessionId",
@@ -16,12 +17,12 @@ export const Type = {
 } as const;
 export type Type = ClosedEnum<typeof Type>;
 
-export type MemoryTranscriptGetRequest = {
+export type TranscriptGetRequest = {
   id: string;
   type?: Type | undefined;
 };
 
-export type MemoryTranscriptGetResponse = {
+export type TranscriptGetResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -35,64 +36,64 @@ export type MemoryTranscriptGetResponse = {
    */
   rawResponse: Response;
   /**
-   * JSON object response.
+   * Session transcript.
    */
-  jsonObjectResponse?: { [k: string]: any } | undefined;
+  sessionTranscript?: models.SessionTranscript | undefined;
 };
 
 /** @internal */
 export const Type$outboundSchema: z.ZodMiniEnum<typeof Type> = z.enum(Type);
 
 /** @internal */
-export type MemoryTranscriptGetRequest$Outbound = {
+export type TranscriptGetRequest$Outbound = {
   id: string;
   type?: string | undefined;
 };
 
 /** @internal */
-export const MemoryTranscriptGetRequest$outboundSchema: z.ZodMiniType<
-  MemoryTranscriptGetRequest$Outbound,
-  MemoryTranscriptGetRequest
+export const TranscriptGetRequest$outboundSchema: z.ZodMiniType<
+  TranscriptGetRequest$Outbound,
+  TranscriptGetRequest
 > = z.object({
   id: z.string(),
   type: z.optional(Type$outboundSchema),
 });
 
-export function memoryTranscriptGetRequestToJSON(
-  memoryTranscriptGetRequest: MemoryTranscriptGetRequest,
+export function transcriptGetRequestToJSON(
+  transcriptGetRequest: TranscriptGetRequest,
 ): string {
   return JSON.stringify(
-    MemoryTranscriptGetRequest$outboundSchema.parse(memoryTranscriptGetRequest),
+    TranscriptGetRequest$outboundSchema.parse(transcriptGetRequest),
   );
 }
 
 /** @internal */
-export const MemoryTranscriptGetResponse$inboundSchema: z.ZodMiniType<
-  MemoryTranscriptGetResponse,
+export const TranscriptGetResponse$inboundSchema: z.ZodMiniType<
+  TranscriptGetResponse,
   unknown
 > = z.pipe(
   z.object({
     ContentType: types.string(),
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
-    JsonObjectResponse: types.optional(z.record(z.string(), z.any())),
+    SessionTranscript: types.optional(models.SessionTranscript$inboundSchema),
   }),
   z.transform((v) => {
     return remap$(v, {
       "ContentType": "contentType",
       "StatusCode": "statusCode",
       "RawResponse": "rawResponse",
-      "JsonObjectResponse": "jsonObjectResponse",
+      "SessionTranscript": "sessionTranscript",
     });
   }),
 );
 
-export function memoryTranscriptGetResponseFromJSON(
+export function transcriptGetResponseFromJSON(
   jsonString: string,
-): SafeParseResult<MemoryTranscriptGetResponse, SDKValidationError> {
+): SafeParseResult<TranscriptGetResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => MemoryTranscriptGetResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MemoryTranscriptGetResponse' from JSON`,
+    (x) => TranscriptGetResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TranscriptGetResponse' from JSON`,
   );
 }

package/generated/{agentic/src/models/operations/memory-vector-index.ts → memory/src/models/operations/transcript-store.ts}

@@ -8,8 +8,9 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
 
-export type MemoryVectorIndexResponse = {
+export type TranscriptStoreResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -23,38 +24,38 @@ export type MemoryVectorIndexResponse = {
    */
   rawResponse: Response;
   /**
-   * JSON object response.
+   * Transcript store result.
    */
-  jsonObjectResponse?: { [k: string]: any } | undefined;
+  successResponse?: models.SuccessResponse | undefined;
 };
 
 /** @internal */
-export const MemoryVectorIndexResponse$inboundSchema: z.ZodMiniType<
-  MemoryVectorIndexResponse,
+export const TranscriptStoreResponse$inboundSchema: z.ZodMiniType<
+  TranscriptStoreResponse,
   unknown
 > = z.pipe(
   z.object({
     ContentType: types.string(),
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
-    JsonObjectResponse: types.optional(z.record(z.string(), z.any())),
+    SuccessResponse: types.optional(models.SuccessResponse$inboundSchema),
   }),
   z.transform((v) => {
     return remap$(v, {
       "ContentType": "contentType",
       "StatusCode": "statusCode",
       "RawResponse": "rawResponse",
-      "JsonObjectResponse": "jsonObjectResponse",
+      "SuccessResponse": "successResponse",
     });
   }),
 );
 
-export function memoryVectorIndexResponseFromJSON(
+export function transcriptStoreResponseFromJSON(
   jsonString: string,
-): SafeParseResult<MemoryVectorIndexResponse, SDKValidationError> {
+): SafeParseResult<TranscriptStoreResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => MemoryVectorIndexResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MemoryVectorIndexResponse' from JSON`,
+    (x) => TranscriptStoreResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TranscriptStoreResponse' from JSON`,
   );
 }

package/generated/memory/src/models/operations/transcripts-index.ts

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+
+export type TranscriptsIndexResponse = {
+  /**
+   * HTTP response content type for this operation
+   */
+  contentType: string;
+  /**
+   * HTTP response status code for this operation
+   */
+  statusCode: number;
+  /**
+   * Raw HTTP response; suitable for custom response parsing
+   */
+  rawResponse: Response;
+  /**
+   * Transcript indexing result.
+   */
+  transcriptIndexResponse?: models.TranscriptIndexResponse | undefined;
+};
+
+/** @internal */
+export const TranscriptsIndexResponse$inboundSchema: z.ZodMiniType<
+  TranscriptsIndexResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    ContentType: types.string(),
+    StatusCode: types.number(),
+    RawResponse: z.custom<Response>(x => x instanceof Response),
+    TranscriptIndexResponse: types.optional(
+      models.TranscriptIndexResponse$inboundSchema,
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "ContentType": "contentType",
+      "StatusCode": "statusCode",
+      "RawResponse": "rawResponse",
+      "TranscriptIndexResponse": "transcriptIndexResponse",
+    });
+  }),
+);
+
+export function transcriptsIndexResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<TranscriptsIndexResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TranscriptsIndexResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TranscriptsIndexResponse' from JSON`,
+  );
+}

package/generated/memory/src/models/operations/turn-record.ts

@@ -0,0 +1,65 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+
+export type TurnRecordResponse = {
+  /**
+   * HTTP response content type for this operation
+   */
+  contentType: string;
+  /**
+   * HTTP response status code for this operation
+   */
+  statusCode: number;
+  /**
+   * Raw HTTP response; suitable for custom response parsing
+   */
+  rawResponse: Response;
+  /**
+   * Turn persistence result.
+   */
+  agentMemoryRecordTurnResponse?:
+    | models.AgentMemoryRecordTurnResponse
+    | undefined;
+};
+
+/** @internal */
+export const TurnRecordResponse$inboundSchema: z.ZodMiniType<
+  TurnRecordResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    ContentType: types.string(),
+    StatusCode: types.number(),
+    RawResponse: z.custom<Response>(x => x instanceof Response),
+    AgentMemoryRecordTurnResponse: types.optional(
+      models.AgentMemoryRecordTurnResponse$inboundSchema,
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "ContentType": "contentType",
+      "StatusCode": "statusCode",
+      "RawResponse": "rawResponse",
+      "AgentMemoryRecordTurnResponse": "agentMemoryRecordTurnResponse",
+    });
+  }),
+);
+
+export function turnRecordResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<TurnRecordResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TurnRecordResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TurnRecordResponse' from JSON`,
+  );
+}

package/generated/{agentic/src/models/operations/memory-layers-search.ts → memory/src/models/operations/vector-index.ts}

@@ -8,8 +8,9 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
 
-export type MemoryLayersSearchResponse = {
+export type VectorIndexResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -23,38 +24,40 @@ export type MemoryLayersSearchResponse = {
    */
   rawResponse: Response;
   /**
-   * JSON object response.
+   * Vector indexing result.
    */
-  jsonObjectResponse?: { [k: string]: any } | undefined;
+  vectorIndexResponse?: models.VectorIndexResponse | undefined;
 };
 
 /** @internal */
-export const MemoryLayersSearchResponse$inboundSchema: z.ZodMiniType<
-  MemoryLayersSearchResponse,
+export const VectorIndexResponse$inboundSchema: z.ZodMiniType<
+  VectorIndexResponse,
   unknown
 > = z.pipe(
   z.object({
     ContentType: types.string(),
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
-    JsonObjectResponse: types.optional(z.record(z.string(), z.any())),
+    VectorIndexResponse: types.optional(
+      models.VectorIndexResponse$inboundSchema,
+    ),
   }),
   z.transform((v) => {
     return remap$(v, {
       "ContentType": "contentType",
       "StatusCode": "statusCode",
       "RawResponse": "rawResponse",
-      "JsonObjectResponse": "jsonObjectResponse",
+      "VectorIndexResponse": "vectorIndexResponse",
     });
   }),
 );
 
-export function memoryLayersSearchResponseFromJSON(
+export function vectorIndexResponseFromJSON(
   jsonString: string,
-): SafeParseResult<MemoryLayersSearchResponse, SDKValidationError> {
+): SafeParseResult<VectorIndexResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => MemoryLayersSearchResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MemoryLayersSearchResponse' from JSON`,
+    (x) => VectorIndexResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VectorIndexResponse' from JSON`,
   );
 }

package/generated/memory/src/models/operations/vector-search.ts

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+
+export type VectorSearchResponse = {
+  /**
+   * HTTP response content type for this operation
+   */
+  contentType: string;
+  /**
+   * HTTP response status code for this operation
+   */
+  statusCode: number;
+  /**
+   * Raw HTTP response; suitable for custom response parsing
+   */
+  rawResponse: Response;
+  /**
+   * Vector search results.
+   */
+  vectorSearchResponse?: models.VectorSearchResponse | undefined;
+};
+
+/** @internal */
+export const VectorSearchResponse$inboundSchema: z.ZodMiniType<
+  VectorSearchResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    ContentType: types.string(),
+    StatusCode: types.number(),
+    RawResponse: z.custom<Response>(x => x instanceof Response),
+    VectorSearchResponse: types.optional(
+      models.VectorSearchResponse$inboundSchema,
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "ContentType": "contentType",
+      "StatusCode": "statusCode",
+      "RawResponse": "rawResponse",
+      "VectorSearchResponse": "vectorSearchResponse",
+    });
+  }),
+);
+
+export function vectorSearchResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<VectorSearchResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VectorSearchResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VectorSearchResponse' from JSON`,
+  );
+}

package/generated/{agentic/src/models/operations/memory-stats-get.ts → memory/src/models/operations/workflows-get.ts}

@@ -8,12 +8,13 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import * as types from "../../types/primitives.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
 
-export type MemoryStatsGetRequest = {
-  agentWallet: string;
+export type WorkflowsGetRequest = {
+  workflowId: string;
 };
 
-export type MemoryStatsGetResponse = {
+export type WorkflowsGetResponse = {
   /**
    * HTTP response content type for this operation
    */
@@ -27,59 +28,61 @@ export type MemoryStatsGetResponse = {
    */
   rawResponse: Response;
   /**
-   * JSON object response.
+   * Memory workflow manifest.
    */
-  jsonObjectResponse?: { [k: string]: any } | undefined;
+  memoryWorkflowResponse?: models.MemoryWorkflowResponse | undefined;
 };
 
 /** @internal */
-export type MemoryStatsGetRequest$Outbound = {
-  agentWallet: string;
+export type WorkflowsGetRequest$Outbound = {
+  workflowId: string;
 };
 
 /** @internal */
-export const MemoryStatsGetRequest$outboundSchema: z.ZodMiniType<
-  MemoryStatsGetRequest$Outbound,
-  MemoryStatsGetRequest
+export const WorkflowsGetRequest$outboundSchema: z.ZodMiniType<
+  WorkflowsGetRequest$Outbound,
+  WorkflowsGetRequest
 > = z.object({
-  agentWallet: z.string(),
+  workflowId: z.string(),
 });
 
-export function memoryStatsGetRequestToJSON(
-  memoryStatsGetRequest: MemoryStatsGetRequest,
+export function workflowsGetRequestToJSON(
+  workflowsGetRequest: WorkflowsGetRequest,
 ): string {
   return JSON.stringify(
-    MemoryStatsGetRequest$outboundSchema.parse(memoryStatsGetRequest),
+    WorkflowsGetRequest$outboundSchema.parse(workflowsGetRequest),
   );
 }
 
 /** @internal */
-export const MemoryStatsGetResponse$inboundSchema: z.ZodMiniType<
-  MemoryStatsGetResponse,
+export const WorkflowsGetResponse$inboundSchema: z.ZodMiniType<
+  WorkflowsGetResponse,
   unknown
 > = z.pipe(
   z.object({
     ContentType: types.string(),
     StatusCode: types.number(),
     RawResponse: z.custom<Response>(x => x instanceof Response),
-    JsonObjectResponse: types.optional(z.record(z.string(), z.any())),
+    MemoryWorkflowResponse: types.optional(
+      models.MemoryWorkflowResponse$inboundSchema,
+    ),
   }),
   z.transform((v) => {
     return remap$(v, {
       "ContentType": "contentType",
       "StatusCode": "statusCode",
       "RawResponse": "rawResponse",
-      "JsonObjectResponse": "jsonObjectResponse",
+      "MemoryWorkflowResponse": "memoryWorkflowResponse",
     });
   }),
 );
 
-export function memoryStatsGetResponseFromJSON(
+export function workflowsGetResponseFromJSON(
   jsonString: string,
-): SafeParseResult<MemoryStatsGetResponse, SDKValidationError> {
+): SafeParseResult<WorkflowsGetResponse, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => MemoryStatsGetResponse$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'MemoryStatsGetResponse' from JSON`,
+    (x) => WorkflowsGetResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorkflowsGetResponse' from JSON`,
   );
 }

package/generated/memory/src/models/operations/workflows-list.ts

@@ -0,0 +1,63 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+
+export type WorkflowsListResponse = {
+  /**
+   * HTTP response content type for this operation
+   */
+  contentType: string;
+  /**
+   * HTTP response status code for this operation
+   */
+  statusCode: number;
+  /**
+   * Raw HTTP response; suitable for custom response parsing
+   */
+  rawResponse: Response;
+  /**
+   * Memory workflow manifests.
+   */
+  memoryWorkflowListResponse?: models.MemoryWorkflowListResponse | undefined;
+};
+
+/** @internal */
+export const WorkflowsListResponse$inboundSchema: z.ZodMiniType<
+  WorkflowsListResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    ContentType: types.string(),
+    StatusCode: types.number(),
+    RawResponse: z.custom<Response>(x => x instanceof Response),
+    MemoryWorkflowListResponse: types.optional(
+      models.MemoryWorkflowListResponse$inboundSchema,
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "ContentType": "contentType",
+      "StatusCode": "statusCode",
+      "RawResponse": "rawResponse",
+      "MemoryWorkflowListResponse": "memoryWorkflowListResponse",
+    });
+  }),
+);
+
+export function workflowsListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<WorkflowsListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => WorkflowsListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'WorkflowsListResponse' from JSON`,
+  );
+}

package/generated/memory/src/models/procedural-pattern-list-response.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  ProceduralPattern,
+  ProceduralPattern$inboundSchema,
+} from "./procedural-pattern.js";
+
+export type ProceduralPatternListResponse = {
+  patterns: Array<ProceduralPattern>;
+};
+
+/** @internal */
+export const ProceduralPatternListResponse$inboundSchema: z.ZodMiniType<
+  ProceduralPatternListResponse,
+  unknown
+> = z.object({
+  patterns: z.array(ProceduralPattern$inboundSchema),
+});
+
+export function proceduralPatternListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ProceduralPatternListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProceduralPatternListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProceduralPatternListResponse' from JSON`,
+  );
+}

package/generated/memory/src/models/procedural-pattern-response.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import {
+  ProceduralPattern,
+  ProceduralPattern$inboundSchema,
+} from "./procedural-pattern.js";
+
+export type ProceduralPatternResponse = {
+  pattern: ProceduralPattern;
+};
+
+/** @internal */
+export const ProceduralPatternResponse$inboundSchema: z.ZodMiniType<
+  ProceduralPatternResponse,
+  unknown
+> = z.object({
+  pattern: ProceduralPattern$inboundSchema,
+});
+
+export function proceduralPatternResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ProceduralPatternResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ProceduralPatternResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ProceduralPatternResponse' from JSON`,
+  );
+}