@compose-market/sdk 0.5.1 → 0.6.2

package/generated/memory/src/models/memory-schedule-status.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type MemoryScheduleStatus = {
+  scheduleId: string;
+  paused: boolean;
+  lastRunAt?: number | undefined;
+  nextRunAt?: number | undefined;
+  note?: string | undefined;
+};
+
+/** @internal */
+export const MemoryScheduleStatus$inboundSchema: z.ZodMiniType<
+  MemoryScheduleStatus,
+  unknown
+> = z.object({
+  scheduleId: types.string(),
+  paused: types.boolean(),
+  lastRunAt: types.optional(types.number()),
+  nextRunAt: types.optional(types.number()),
+  note: types.optional(types.string()),
+});
+
+export function memoryScheduleStatusFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryScheduleStatus, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryScheduleStatus$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryScheduleStatus' from JSON`,
+  );
+}

package/generated/memory/src/models/memory-schedule-trigger-response.ts

@@ -0,0 +1,31 @@
+/*
+ * 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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type MemoryScheduleTriggerResponse = {
+  triggered: boolean;
+};
+
+/** @internal */
+export const MemoryScheduleTriggerResponse$inboundSchema: z.ZodMiniType<
+  MemoryScheduleTriggerResponse,
+  unknown
+> = z.object({
+  triggered: types.boolean(),
+});
+
+export function memoryScheduleTriggerResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryScheduleTriggerResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryScheduleTriggerResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryScheduleTriggerResponse' from JSON`,
+  );
+}

package/generated/{agentic → memory}/src/models/memory-search-request.ts

@@ -4,6 +4,19 @@
 
 import * as z from "zod/v4-mini";
 import { remap as remap$ } from "../lib/primitives.js";
+import { ClosedEnum } from "../types/enums.js";
+import {
+  AgentMemoryLayer,
+  AgentMemoryLayer$outboundSchema,
+} from "./agent-memory-layer.js";
+
+export const MemorySearchRequestMode = {
+  Global: "global",
+  Local: "local",
+} as const;
+export type MemorySearchRequestMode = ClosedEnum<
+  typeof MemorySearchRequestMode
+>;
 
 export type MemorySearchRequest = {
   query: string;
@@ -13,12 +26,19 @@ export type MemorySearchRequest = {
   userId?: string | undefined;
   threadId?: string | undefined;
   runId?: string | undefined;
+  mode?: MemorySearchRequestMode | undefined;
+  haiId?: string | undefined;
   limit?: number | undefined;
-  layers?: Array<string> | undefined;
+  layers?: Array<AgentMemoryLayer> | undefined;
   filters?: { [k: string]: any } | undefined;
   rerank?: boolean | undefined;
 };
 
+/** @internal */
+export const MemorySearchRequestMode$outboundSchema: z.ZodMiniEnum<
+  typeof MemorySearchRequestMode
+> = z.enum(MemorySearchRequestMode);
+
 /** @internal */
 export type MemorySearchRequest$Outbound = {
   query: string;
@@ -28,6 +48,8 @@ export type MemorySearchRequest$Outbound = {
   user_id?: string | undefined;
   threadId?: string | undefined;
   runId?: string | undefined;
+  mode?: string | undefined;
+  haiId?: string | undefined;
   limit?: number | undefined;
   layers?: Array<string> | undefined;
   filters?: { [k: string]: any } | undefined;
@@ -47,8 +69,10 @@ export const MemorySearchRequest$outboundSchema: z.ZodMiniType<
     userId: z.optional(z.string()),
     threadId: z.optional(z.string()),
     runId: z.optional(z.string()),
+    mode: z.optional(MemorySearchRequestMode$outboundSchema),
+    haiId: z.optional(z.string()),
     limit: z.optional(z.int()),
-    layers: z.optional(z.array(z.string())),
+    layers: z.optional(z.array(AgentMemoryLayer$outboundSchema)),
     filters: z.optional(z.record(z.string(), z.any())),
     rerank: z.optional(z.boolean()),
   }),

package/generated/memory/src/models/memory-stats-response.ts

@@ -0,0 +1,41 @@
+/*
+ * 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 * as types from "../types/primitives.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+
+export type MemoryStatsResponse = {
+  totalVectors: number;
+  totalTranscripts: number;
+  avgDecayScore: number;
+  oldestVector: number;
+  newestVector: number;
+  byType: { [k: string]: number };
+};
+
+/** @internal */
+export const MemoryStatsResponse$inboundSchema: z.ZodMiniType<
+  MemoryStatsResponse,
+  unknown
+> = z.object({
+  totalVectors: types.number(),
+  totalTranscripts: types.number(),
+  avgDecayScore: types.number(),
+  oldestVector: types.number(),
+  newestVector: types.number(),
+  byType: z.record(z.string(), types.number()),
+});
+
+export function memoryStatsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryStatsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryStatsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryStatsResponse' from JSON`,
+  );
+}

package/generated/memory/src/models/memory-time-range.ts

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+
+export type MemoryTimeRange = {
+  start: number;
+  end: number;
+};
+
+/** @internal */
+export type MemoryTimeRange$Outbound = {
+  start: number;
+  end: number;
+};
+
+/** @internal */
+export const MemoryTimeRange$outboundSchema: z.ZodMiniType<
+  MemoryTimeRange$Outbound,
+  MemoryTimeRange
+> = z.object({
+  start: z.int(),
+  end: z.int(),
+});
+
+export function memoryTimeRangeToJSON(
+  memoryTimeRange: MemoryTimeRange,
+): string {
+  return JSON.stringify(MemoryTimeRange$outboundSchema.parse(memoryTimeRange));
+}

package/generated/memory/src/models/memory-vector-item.ts

@@ -0,0 +1,92 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } 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";
+
+export const MemoryVectorItemSource = {
+  Session: "session",
+  Knowledge: "knowledge",
+  Pattern: "pattern",
+  Archive: "archive",
+  Fact: "fact",
+} as const;
+export type MemoryVectorItemSource = OpenEnum<typeof MemoryVectorItemSource>;
+
+export const MemoryVectorItemMode = {
+  Global: "global",
+  Local: "local",
+} as const;
+export type MemoryVectorItemMode = OpenEnum<typeof MemoryVectorItemMode>;
+
+export type MemoryVectorItem = {
+  id: string;
+  vectorId?: string | undefined;
+  content: string;
+  score: number;
+  source: MemoryVectorItemSource;
+  agentWallet: string;
+  userAddress?: string | undefined;
+  threadId?: string | undefined;
+  mode?: MemoryVectorItemMode | undefined;
+  haiId?: string | undefined;
+  decayScore: number;
+  accessCount: number;
+  createdAt: number;
+  embedding?: Array<number> | undefined;
+  metadata?: { [k: string]: any } | undefined;
+  lastAccessedAt?: number | undefined;
+  updatedAt?: number | undefined;
+};
+
+/** @internal */
+export const MemoryVectorItemSource$inboundSchema: z.ZodMiniType<
+  MemoryVectorItemSource,
+  unknown
+> = openEnums.inboundSchema(MemoryVectorItemSource);
+
+/** @internal */
+export const MemoryVectorItemMode$inboundSchema: z.ZodMiniType<
+  MemoryVectorItemMode,
+  unknown
+> = openEnums.inboundSchema(MemoryVectorItemMode);
+
+/** @internal */
+export const MemoryVectorItem$inboundSchema: z.ZodMiniType<
+  MemoryVectorItem,
+  unknown
+> = z.object({
+  id: types.string(),
+  vectorId: types.optional(types.string()),
+  content: types.string(),
+  score: types.number(),
+  source: MemoryVectorItemSource$inboundSchema,
+  agentWallet: types.string(),
+  userAddress: types.optional(types.string()),
+  threadId: types.optional(types.string()),
+  mode: types.optional(MemoryVectorItemMode$inboundSchema),
+  haiId: types.optional(types.string()),
+  decayScore: types.number(),
+  accessCount: types.number(),
+  createdAt: types.number(),
+  embedding: types.optional(z.array(types.number())),
+  metadata: types.optional(z.record(z.string(), z.any())),
+  lastAccessedAt: types.optional(types.number()),
+  updatedAt: types.optional(types.number()),
+});
+
+export function memoryVectorItemFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryVectorItem, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryVectorItem$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryVectorItem' from JSON`,
+  );
+}

package/generated/memory/src/models/memory-workflow-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 {
+  MemoryWorkflowManifest,
+  MemoryWorkflowManifest$inboundSchema,
+} from "./memory-workflow-manifest.js";
+
+export type MemoryWorkflowListResponse = {
+  workflows: Array<MemoryWorkflowManifest>;
+};
+
+/** @internal */
+export const MemoryWorkflowListResponse$inboundSchema: z.ZodMiniType<
+  MemoryWorkflowListResponse,
+  unknown
+> = z.object({
+  workflows: z.array(MemoryWorkflowManifest$inboundSchema),
+});
+
+export function memoryWorkflowListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryWorkflowListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryWorkflowListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryWorkflowListResponse' from JSON`,
+  );
+}

package/generated/memory/src/models/memory-workflow-manifest.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } 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 {
+  MemoryWorkflowStepManifest,
+  MemoryWorkflowStepManifest$inboundSchema,
+} from "./memory-workflow-step-manifest.js";
+
+export const Loop = {
+  Hot: "hot",
+  Durable: "durable",
+  Maintenance: "maintenance",
+} as const;
+export type Loop = OpenEnum<typeof Loop>;
+
+export const TokenPolicy = {
+  ReturnsCompactPromptOnly: "returns compact prompt only",
+  ReturnsMetadataOnly: "returns metadata only",
+} as const;
+export type TokenPolicy = OpenEnum<typeof TokenPolicy>;
+
+export type MemoryWorkflowManifest = {
+  id: string;
+  version: "compose.agent_memory.v1";
+  description: string;
+  loop: Loop;
+  tokenPolicy: TokenPolicy;
+  steps: Array<MemoryWorkflowStepManifest>;
+};
+
+/** @internal */
+export const Loop$inboundSchema: z.ZodMiniType<Loop, unknown> = openEnums
+  .inboundSchema(Loop);
+
+/** @internal */
+export const TokenPolicy$inboundSchema: z.ZodMiniType<TokenPolicy, unknown> =
+  openEnums.inboundSchema(TokenPolicy);
+
+/** @internal */
+export const MemoryWorkflowManifest$inboundSchema: z.ZodMiniType<
+  MemoryWorkflowManifest,
+  unknown
+> = z.object({
+  id: types.string(),
+  version: types.literal("compose.agent_memory.v1"),
+  description: types.string(),
+  loop: Loop$inboundSchema,
+  tokenPolicy: TokenPolicy$inboundSchema,
+  steps: z.array(MemoryWorkflowStepManifest$inboundSchema),
+});
+
+export function memoryWorkflowManifestFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryWorkflowManifest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryWorkflowManifest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryWorkflowManifest' from JSON`,
+  );
+}

package/generated/memory/src/models/memory-workflow-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 {
+  MemoryWorkflowManifest,
+  MemoryWorkflowManifest$inboundSchema,
+} from "./memory-workflow-manifest.js";
+
+export type MemoryWorkflowResponse = {
+  workflow: MemoryWorkflowManifest;
+};
+
+/** @internal */
+export const MemoryWorkflowResponse$inboundSchema: z.ZodMiniType<
+  MemoryWorkflowResponse,
+  unknown
+> = z.object({
+  workflow: MemoryWorkflowManifest$inboundSchema,
+});
+
+export function memoryWorkflowResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryWorkflowResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryWorkflowResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryWorkflowResponse' from JSON`,
+  );
+}

package/generated/memory/src/models/memory-workflow-step-manifest.ts

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import { OpenEnum } 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";
+
+export const Method = {
+  Get: "GET",
+  Post: "POST",
+  Patch: "PATCH",
+  Delete: "DELETE",
+} as const;
+export type Method = OpenEnum<typeof Method>;
+
+export type MemoryWorkflowStepManifest = {
+  operationId: string;
+  method: Method;
+  path: string;
+  purpose: string;
+};
+
+/** @internal */
+export const Method$inboundSchema: z.ZodMiniType<Method, unknown> = openEnums
+  .inboundSchema(Method);
+
+/** @internal */
+export const MemoryWorkflowStepManifest$inboundSchema: z.ZodMiniType<
+  MemoryWorkflowStepManifest,
+  unknown
+> = z.object({
+  operationId: types.string(),
+  method: Method$inboundSchema,
+  path: types.string(),
+  purpose: types.string(),
+});
+
+export function memoryWorkflowStepManifestFromJSON(
+  jsonString: string,
+): SafeParseResult<MemoryWorkflowStepManifest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => MemoryWorkflowStepManifest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'MemoryWorkflowStepManifest' from JSON`,
+  );
+}

package/generated/memory/src/models/operations/archives-sync.ts

@@ -0,0 +1,91 @@
+/*
+ * 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 ArchivesSyncRequest = {
+  archiveId: string;
+  body: models.ArchiveSyncRequest;
+};
+
+export type ArchivesSyncResponse = {
+  /**
+   * 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;
+  /**
+   * Archive sync result.
+   */
+  archiveSyncResponse?: models.ArchiveSyncResponse | undefined;
+};
+
+/** @internal */
+export type ArchivesSyncRequest$Outbound = {
+  archiveId: string;
+  body: models.ArchiveSyncRequest$Outbound;
+};
+
+/** @internal */
+export const ArchivesSyncRequest$outboundSchema: z.ZodMiniType<
+  ArchivesSyncRequest$Outbound,
+  ArchivesSyncRequest
+> = z.object({
+  archiveId: z.string(),
+  body: models.ArchiveSyncRequest$outboundSchema,
+});
+
+export function archivesSyncRequestToJSON(
+  archivesSyncRequest: ArchivesSyncRequest,
+): string {
+  return JSON.stringify(
+    ArchivesSyncRequest$outboundSchema.parse(archivesSyncRequest),
+  );
+}
+
+/** @internal */
+export const ArchivesSyncResponse$inboundSchema: z.ZodMiniType<
+  ArchivesSyncResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    ContentType: types.string(),
+    StatusCode: types.number(),
+    RawResponse: z.custom<Response>(x => x instanceof Response),
+    ArchiveSyncResponse: types.optional(
+      models.ArchiveSyncResponse$inboundSchema,
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "ContentType": "contentType",
+      "StatusCode": "statusCode",
+      "RawResponse": "rawResponse",
+      "ArchiveSyncResponse": "archiveSyncResponse",
+    });
+  }),
+);
+
+export function archivesSyncResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ArchivesSyncResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ArchivesSyncResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ArchivesSyncResponse' from JSON`,
+  );
+}

package/generated/memory/src/models/operations/conflicts-resolve.ts

@@ -0,0 +1,93 @@
+/*
+ * 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 ConflictsResolveRequest = {
+  id: string;
+  body: models.MemoryConflictResolveRequest;
+};
+
+export type ConflictsResolveResponse = {
+  /**
+   * 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;
+  /**
+   * Conflict resolution result.
+   */
+  memoryConflictResolveResponse?:
+    | models.MemoryConflictResolveResponse
+    | undefined;
+};
+
+/** @internal */
+export type ConflictsResolveRequest$Outbound = {
+  id: string;
+  body: models.MemoryConflictResolveRequest$Outbound;
+};
+
+/** @internal */
+export const ConflictsResolveRequest$outboundSchema: z.ZodMiniType<
+  ConflictsResolveRequest$Outbound,
+  ConflictsResolveRequest
+> = z.object({
+  id: z.string(),
+  body: models.MemoryConflictResolveRequest$outboundSchema,
+});
+
+export function conflictsResolveRequestToJSON(
+  conflictsResolveRequest: ConflictsResolveRequest,
+): string {
+  return JSON.stringify(
+    ConflictsResolveRequest$outboundSchema.parse(conflictsResolveRequest),
+  );
+}
+
+/** @internal */
+export const ConflictsResolveResponse$inboundSchema: z.ZodMiniType<
+  ConflictsResolveResponse,
+  unknown
+> = z.pipe(
+  z.object({
+    ContentType: types.string(),
+    StatusCode: types.number(),
+    RawResponse: z.custom<Response>(x => x instanceof Response),
+    MemoryConflictResolveResponse: types.optional(
+      models.MemoryConflictResolveResponse$inboundSchema,
+    ),
+  }),
+  z.transform((v) => {
+    return remap$(v, {
+      "ContentType": "contentType",
+      "StatusCode": "statusCode",
+      "RawResponse": "rawResponse",
+      "MemoryConflictResolveResponse": "memoryConflictResolveResponse",
+    });
+  }),
+);
+
+export function conflictsResolveResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<ConflictsResolveResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ConflictsResolveResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ConflictsResolveResponse' from JSON`,
+  );
+}