@compose-market/sdk 0.5.1 → 0.6.0

package/generated/memory/src/sdk/memory.ts

@@ -0,0 +1,636 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { memoryArchivesSync } from "../funcs/memory-archives-sync.js";
+import { memoryConflictsResolve } from "../funcs/memory-conflicts-resolve.js";
+import { memoryContextAssemble } from "../funcs/memory-context-assemble.js";
+import { memoryEvalsRun } from "../funcs/memory-evals-run.js";
+import { memoryGraphAdd } from "../funcs/memory-graph-add.js";
+import { memoryGraphSearch } from "../funcs/memory-graph-search.js";
+import { memoryItemsDelete } from "../funcs/memory-items-delete.js";
+import { memoryItemsGet } from "../funcs/memory-items-get.js";
+import { memoryItemsSearch } from "../funcs/memory-items-search.js";
+import { memoryItemsUpdate } from "../funcs/memory-items-update.js";
+import { memoryJobsCreate } from "../funcs/memory-jobs-create.js";
+import { memoryJobsGet } from "../funcs/memory-jobs-get.js";
+import { memoryLayersSearch } from "../funcs/memory-layers-search.js";
+import { memoryList } from "../funcs/memory-list.js";
+import { memoryLoop } from "../funcs/memory-loop.js";
+import { memoryPatternsGet } from "../funcs/memory-patterns-get.js";
+import { memoryPatternsList } from "../funcs/memory-patterns-list.js";
+import { memoryPatternsPromote } from "../funcs/memory-patterns-promote.js";
+import { memoryPatternsValidate } from "../funcs/memory-patterns-validate.js";
+import { memoryRemember } from "../funcs/memory-remember.js";
+import { memoryRerank } from "../funcs/memory-rerank.js";
+import { memorySchedulesCreate } from "../funcs/memory-schedules-create.js";
+import { memorySchedulesDelete } from "../funcs/memory-schedules-delete.js";
+import { memorySchedulesList } from "../funcs/memory-schedules-list.js";
+import { memorySchedulesPause } from "../funcs/memory-schedules-pause.js";
+import { memorySchedulesResume } from "../funcs/memory-schedules-resume.js";
+import { memorySchedulesTrigger } from "../funcs/memory-schedules-trigger.js";
+import { memorySessionsCompress } from "../funcs/memory-sessions-compress.js";
+import { memorySessionsWorkingGet } from "../funcs/memory-sessions-working-get.js";
+import { memorySessionsWorkingUpdate } from "../funcs/memory-sessions-working-update.js";
+import { memorySkillsGet } from "../funcs/memory-skills-get.js";
+import { memorySkillsList } from "../funcs/memory-skills-list.js";
+import { memoryStatsGet } from "../funcs/memory-stats-get.js";
+import { memoryTranscriptGet } from "../funcs/memory-transcript-get.js";
+import { memoryTranscriptStore } from "../funcs/memory-transcript-store.js";
+import { memoryTranscriptsIndex } from "../funcs/memory-transcripts-index.js";
+import { memoryTurnRecord } from "../funcs/memory-turn-record.js";
+import { memoryVectorIndex } from "../funcs/memory-vector-index.js";
+import { memoryVectorSearch } from "../funcs/memory-vector-search.js";
+import { memoryWorkflowsGet } from "../funcs/memory-workflows-get.js";
+import { memoryWorkflowsList } from "../funcs/memory-workflows-list.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Memory extends ClientSDK {
+  /**
+   * Assemble compact pre-turn memory context.
+   *
+   * @remarks
+   * Agent-first workflow step. Call before reasoning or tool use. Returns a
+   * compact prompt and structured memory items across working, scene, graph,
+   * patterns, archives, and vectors.
+   */
+  async contextAssemble(
+    request: models.AgentMemoryContextRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ContextAssembleResponse> {
+    return unwrapAsync(memoryContextAssemble(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Persist the completed turn.
+   *
+   * @remarks
+   * Agent-first workflow step. Call after the assistant final answer to store
+   * transcript, working memory, and vector memory for later retrieval.
+   */
+  async turnRecord(
+    request: models.AgentMemoryRecordTurnRequest,
+    options?: RequestOptions,
+  ): Promise<operations.TurnRecordResponse> {
+    return unwrapAsync(memoryTurnRecord(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Save an explicit durable fact or preference.
+   *
+   * @remarks
+   * Agent-first workflow step. Call when the agent identifies a durable fact,
+   * preference, correction, decision, or operational lesson.
+   */
+  async remember(
+    request: models.AgentMemoryRememberRequest,
+    options?: RequestOptions,
+  ): Promise<operations.RememberResponse> {
+    return unwrapAsync(memoryRemember(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Single endpoint for the agent memory loop.
+   *
+   * @remarks
+   * Minimal-token agent surface. Set `step` to `pre_turn`, `post_turn`, or
+   * `remember`; each response returns the next valid loop steps.
+   */
+  async loop(
+    request: models.AgentMemoryLoopRequest,
+    options?: RequestOptions,
+  ): Promise<operations.LoopResponse> {
+    return unwrapAsync(memoryLoop(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List compact agent-first memory workflow manifests.
+   */
+  async workflowsList(
+    options?: RequestOptions,
+  ): Promise<operations.WorkflowsListResponse> {
+    return unwrapAsync(memoryWorkflowsList(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Fetch one compact memory workflow manifest.
+   */
+  async workflowsGet(
+    request: operations.WorkflowsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.WorkflowsGetResponse> {
+    return unwrapAsync(memoryWorkflowsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List learned procedural memory patterns.
+   */
+  async patternsList(
+    request?: operations.PatternsListRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.PatternsListResponse> {
+    return unwrapAsync(memoryPatternsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Fetch one procedural memory pattern.
+   */
+  async patternsGet(
+    request: operations.PatternsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatternsGetResponse> {
+    return unwrapAsync(memoryPatternsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Validate a procedural memory pattern before promotion.
+   */
+  async patternsValidate(
+    request: operations.PatternsValidateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatternsValidateResponse> {
+    return unwrapAsync(memoryPatternsValidate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Promote a validated procedural pattern into a learned skill.
+   */
+  async patternsPromote(
+    request: operations.PatternsPromoteRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatternsPromoteResponse> {
+    return unwrapAsync(memoryPatternsPromote(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List learned memory skills.
+   */
+  async skillsList(
+    request?: operations.SkillsListRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.SkillsListResponse> {
+    return unwrapAsync(memorySkillsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Fetch one learned memory skill.
+   */
+  async skillsGet(
+    request: operations.SkillsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SkillsGetResponse> {
+    return unwrapAsync(memorySkillsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Add graph memory through the configured graph provider.
+   */
+  async graphAdd(
+    request: models.MemoryAddRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GraphAddResponse> {
+    return unwrapAsync(memoryGraphAdd(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search graph memory through the configured graph provider.
+   */
+  async graphSearch(
+    request: models.MemorySearchRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GraphSearchResponse> {
+    return unwrapAsync(memoryGraphSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List memories for an agent wallet.
+   */
+  async list(
+    request: operations.ListRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ListResponse> {
+    return unwrapAsync(memoryList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search vector memory.
+   */
+  async vectorSearch(
+    request: models.VectorSearchRequest,
+    options?: RequestOptions,
+  ): Promise<operations.VectorSearchResponse> {
+    return unwrapAsync(memoryVectorSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Index a memory vector.
+   */
+  async vectorIndex(
+    request: models.VectorIndexRequest,
+    options?: RequestOptions,
+  ): Promise<operations.VectorIndexResponse> {
+    return unwrapAsync(memoryVectorIndex(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Store a session transcript.
+   */
+  async transcriptStore(
+    request: models.TranscriptStoreRequest,
+    options?: RequestOptions,
+  ): Promise<operations.TranscriptStoreResponse> {
+    return unwrapAsync(memoryTranscriptStore(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Fetch a transcript by session or thread id.
+   */
+  async transcriptGet(
+    request: operations.TranscriptGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.TranscriptGetResponse> {
+    return unwrapAsync(memoryTranscriptGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Store, index, and optionally update working memory from a transcript.
+   */
+  async transcriptsIndex(
+    request: models.TranscriptIndexRequest,
+    options?: RequestOptions,
+  ): Promise<operations.TranscriptsIndexResponse> {
+    return unwrapAsync(memoryTranscriptsIndex(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Fetch hot working memory for a session.
+   */
+  async sessionsWorkingGet(
+    request: operations.SessionsWorkingGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SessionsWorkingGetResponse> {
+    return unwrapAsync(memorySessionsWorkingGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update hot working memory for a session.
+   */
+  async sessionsWorkingUpdate(
+    request: operations.SessionsWorkingUpdateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SessionsWorkingUpdateResponse> {
+    return unwrapAsync(memorySessionsWorkingUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Compress a long transcript into durable archive memory.
+   */
+  async sessionsCompress(
+    request: operations.SessionsCompressRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SessionsCompressResponse> {
+    return unwrapAsync(memorySessionsCompress(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Sync a memory archive to durable external storage.
+   */
+  async archivesSync(
+    request: operations.ArchivesSyncRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ArchivesSyncResponse> {
+    return unwrapAsync(memoryArchivesSync(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List Temporal memory schedule status.
+   */
+  async schedulesList(
+    options?: RequestOptions,
+  ): Promise<operations.SchedulesListResponse> {
+    return unwrapAsync(memorySchedulesList(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Create or replace memory maintenance schedules.
+   */
+  async schedulesCreate(
+    request: models.MemoryScheduleCreateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SchedulesCreateResponse> {
+    return unwrapAsync(memorySchedulesCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete memory maintenance schedules.
+   */
+  async schedulesDelete(
+    options?: RequestOptions,
+  ): Promise<operations.SchedulesDeleteResponse> {
+    return unwrapAsync(memorySchedulesDelete(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Pause one memory maintenance schedule.
+   */
+  async schedulesPause(
+    request: operations.SchedulesPauseRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SchedulesPauseResponse> {
+    return unwrapAsync(memorySchedulesPause(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Resume one memory maintenance schedule.
+   */
+  async schedulesResume(
+    request: operations.SchedulesResumeRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SchedulesResumeResponse> {
+    return unwrapAsync(memorySchedulesResume(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Trigger one memory maintenance schedule immediately.
+   */
+  async schedulesTrigger(
+    request: operations.SchedulesTriggerRequest,
+    options?: RequestOptions,
+  ): Promise<operations.SchedulesTriggerResponse> {
+    return unwrapAsync(memorySchedulesTrigger(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Rerank candidate memory documents.
+   */
+  async rerank(
+    request: operations.RerankRequest,
+    options?: RequestOptions,
+  ): Promise<operations.RerankResponse> {
+    return unwrapAsync(memoryRerank(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search all memory layers.
+   */
+  async layersSearch(
+    request: models.MemorySearchRequest,
+    options?: RequestOptions,
+  ): Promise<operations.LayersSearchResponse> {
+    return unwrapAsync(memoryLayersSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get memory statistics for an agent wallet.
+   */
+  async statsGet(
+    request: operations.StatsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.StatsGetResponse> {
+    return unwrapAsync(memoryStatsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Search productized memory items across layers.
+   */
+  async itemsSearch(
+    request: models.MemorySearchRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ItemsSearchResponse> {
+    return unwrapAsync(memoryItemsSearch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Fetch one durable memory item.
+   */
+  async itemsGet(
+    request: operations.ItemsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ItemsGetResponse> {
+    return unwrapAsync(memoryItemsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update one durable memory item.
+   */
+  async itemsUpdate(
+    request: operations.ItemsUpdateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ItemsUpdateResponse> {
+    return unwrapAsync(memoryItemsUpdate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete or soft-delete one durable memory item.
+   */
+  async itemsDelete(
+    request: operations.ItemsDeleteRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ItemsDeleteResponse> {
+    return unwrapAsync(memoryItemsDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Resolve a memory conflict.
+   */
+  async conflictsResolve(
+    request: operations.ConflictsResolveRequest,
+    options?: RequestOptions,
+  ): Promise<operations.ConflictsResolveResponse> {
+    return unwrapAsync(memoryConflictsResolve(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Run a memory maintenance job.
+   */
+  async jobsCreate(
+    request: models.MemoryJobCreateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.JobsCreateResponse> {
+    return unwrapAsync(memoryJobsCreate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Fetch a memory maintenance job.
+   */
+  async jobsGet(
+    request: operations.JobsGetRequest,
+    options?: RequestOptions,
+  ): Promise<operations.JobsGetResponse> {
+    return unwrapAsync(memoryJobsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Run a memory retrieval evaluation.
+   */
+  async evalsRun(
+    request: models.MemoryEvalRunRequest,
+    options?: RequestOptions,
+  ): Promise<operations.EvalsRunResponse> {
+    return unwrapAsync(memoryEvalsRun(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/generated/memory/src/sdk/sdk.ts

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { ClientSDK } from "../lib/sdks.js";
+import { Memory } from "./memory.js";
+
+export class ComposeMarket extends ClientSDK {
+  private _memory?: Memory;
+  get memory(): Memory {
+    return (this._memory ??= new Memory(this._options));
+  }
+}

package/generated/memory/src/types/async.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+export type APICall =
+  | {
+      status: "complete";
+      request: Request;
+      response: Response;
+    }
+  | {
+      status: "request-error";
+      request: Request;
+      response?: undefined;
+    }
+  | {
+      status: "invalid";
+      request?: undefined;
+      response?: undefined;
+    };
+
+export class APIPromise<T> implements Promise<T> {
+  readonly #promise: Promise<[T, APICall]>;
+  readonly #unwrapped: Promise<T>;
+
+  readonly [Symbol.toStringTag] = "APIPromise";
+
+  constructor(p: [T, APICall] | Promise<[T, APICall]>) {
+    this.#promise = p instanceof Promise ? p : Promise.resolve(p);
+    this.#unwrapped =
+      p instanceof Promise
+        ? this.#promise.then(([value]) => value)
+        : Promise.resolve(p[0]);
+  }
+
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?:
+      | ((value: T) => TResult1 | PromiseLike<TResult1>)
+      | null
+      | undefined,
+    onrejected?:
+      | ((reason: any) => TResult2 | PromiseLike<TResult2>)
+      | null
+      | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.#promise.then(
+      onfulfilled ? ([value]) => onfulfilled(value) : void 0,
+      onrejected,
+    );
+  }
+
+  catch<TResult = never>(
+    onrejected?:
+      | ((reason: any) => TResult | PromiseLike<TResult>)
+      | null
+      | undefined,
+  ): Promise<T | TResult> {
+    return this.#unwrapped.catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.#unwrapped.finally(onfinally);
+  }
+
+  $inspect(): Promise<[T, APICall]> {
+    return this.#promise;
+  }
+}