@cadenya/cadenya 0.44.0 → 0.46.0

package/src/resources/objectives/objectives.ts

@@ -207,6 +207,51 @@ export interface ContextWindowCompacted {
   summary?: string;
 }
 
+/**
+ * MemoryRead is emitted each time the agent resolves a key against the memory
+ * stack and loads an entry. Lookups that miss (key not found in any layer) do not
+ * emit this event.
+ */
+export interface MemoryRead {
+  /**
+   * The specific entry that was read.
+   */
+  memoryEntryId?: string;
+
+  /**
+   * The layer the entry resolved to. The top-most layer that contained the key —
+   * other layers beneath it that also contained the key are shadowed and not
+   * referenced here.
+   */
+  memoryLayerId?: string;
+
+  /**
+   * Human-readable description of the read, set by the runtime. For example: "Loaded
+   * skill", "Resolved context key". Not machine-parsed; intended for UI display
+   * alongside the other events in an objective's timeline.
+   */
+  message?: string;
+}
+
+/**
+ * MemoryReference identifies a memory layer or a specific entry within one, for
+ * composition into a memory stack. Used on objectives (where entry pinning is
+ * permitted).
+ *
+ * memory*layer_id accepts both the canonical form (memlyr*…) and the external-id
+ * form (external_id:my-custom-id). The same applies to memory_entry_id.
+ */
+export interface MemoryReference {
+  /**
+   * When set, pushes only this entry from memory_layer_id onto the stack — behaves
+   * as a single-entry layer (only this key resolves at this position). The entry
+   * must belong to memory_layer_id; mismatches are rejected with InvalidArgument.
+   */
+  memoryEntryId?: string;
+
+  memoryLayerId?: string;
+}
+
 export interface Objective {
   data: ObjectiveData;
 
@@ -316,6 +361,29 @@ export interface ObjectiveData {
    */
   initialMessage?: string;
 
+  /**
+   * Memory layers/entries to push onto this objective's memory stack on top of the
+   * baseline stack inherited from the selected variation.
+   *
+   * See "Memory stack composition" in memory.proto for lookup semantics.
+   *
+   * Array order is push order: the first element sits lower in the objective's
+   * contribution to the stack; the LAST element ends up on top of the effective
+   * stack. Entries pinned via memory_entry_id behave as single-entry layers at their
+   * position.
+   *
+   * System-managed layers (e.g., episodic) cannot be referenced here; they attach
+   * themselves automatically via the runtime based on episodic_key.
+   *
+   * Stack size cap: the TOTAL effective stack (variation's memory layers
+   *
+   * - this field) must not exceed 10 entries. A request that would produce an
+   *   effective stack larger than 10 is rejected with InvalidArgument. Variations
+   *   themselves are capped at 10 memory layer assignments, so a variation that is
+   *   already "full" leaves no room for objective-level references.
+   */
+  memoryStack?: Array<MemoryReference>;
+
   /**
    * A parent objective means the objective was spawned off using a separate agent to
    * complete an objective
@@ -358,6 +426,13 @@ export interface ObjectiveEventData {
 
   error?: ObjectiveError;
 
+  /**
+   * MemoryRead is emitted each time the agent resolves a key against the memory
+   * stack and loads an entry. Lookups that miss (key not found in any layer) do not
+   * emit this event.
+   */
+  memoryRead?: MemoryRead;
+
   subObjectiveCreated?: SubObjectiveCreated;
 
   toolApprovalRequested?: ToolApprovalRequested;
@@ -472,6 +547,14 @@ export interface ObjectiveInfo {
    */
   createdBy?: AccountAPI.Profile;
 
+  /**
+   * The effective memory stack at objective creation time, flattened from the
+   * variation's baseline plus ObjectiveData.memory_stack. Order is push order (last
+   * = top). Returned on reads so clients can see exactly what stack the objective is
+   * using without having to re-join variation state.
+   */
+  effectiveMemoryStack?: Array<MemoryReference>;
+
   /**
    * Total number of context windows that this objective has generated
    */
@@ -746,6 +829,8 @@ export declare namespace Objectives {
     type AssistantToolCall as AssistantToolCall,
     type CallableTool as CallableTool,
     type ContextWindowCompacted as ContextWindowCompacted,
+    type MemoryRead as MemoryRead,
+    type MemoryReference as MemoryReference,
     type Objective as Objective,
     type ObjectiveContextWindow as ObjectiveContextWindow,
     type ObjectiveContextWindowData as ObjectiveContextWindowData,

package/src/resources/uploads.ts

@@ -0,0 +1,128 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import * as AccountAPI from './account';
+import * as Shared from './shared';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+import { path } from '../internal/utils/path';
+
+/**
+ * UploadService issues short-lived presigned URLs for direct client-to-object-
+ *  storage uploads at the WORKSPACE level. Created uploads can be referenced by
+ *  id when creating or updating resources that accept binary content (e.g.,
+ *  MemoryEntry).
+ *
+ *  Authentication: Bearer token (JWT)
+ *  Scope: Workspace-level operations
+ */
+export class Uploads extends APIResource {
+  /**
+   * Issues a short-lived presigned URL for direct upload to object storage. The
+   * returned id is used to reference the upload from resources that accept binary
+   * content.
+   */
+  create(body: UploadCreateParams, options?: RequestOptions): APIPromise<Upload> {
+    return this._client.post('/v1/uploads', { body, ...options });
+  }
+
+  /**
+   * Retrieves the current state of an upload, including its lifecycle status
+   */
+  retrieve(id: string, options?: RequestOptions): APIPromise<Upload> {
+    return this._client.get(path`/v1/uploads/${id}`, options);
+  }
+}
+
+/**
+ * Upload is a workspace-scoped handle representing a single file upload flow.
+ * Clients call CreateUpload to receive a short-lived presigned URL, PUT the file
+ * directly to object storage, then reference the upload by id when creating or
+ * updating resources that accept binary content.
+ *
+ * Uploads are one-shot: once consumed by a creating or updating resource, the
+ * upload transitions to UPLOAD_STATUS_CONSUMED and cannot be reused. Unused
+ * uploads expire and are garbage-collected by the runtime.
+ */
+export interface Upload {
+  info: UploadInfo;
+
+  /**
+   * Standard metadata for persistent, named resources (e.g., agents, tools, prompts)
+   */
+  metadata: Shared.ResourceMetadata;
+
+  spec: UploadSpec;
+}
+
+export interface UploadInfo {
+  /**
+   * Profile represents a human user at the account level. Profiles are
+   * account-scoped resources that can be associated with multiple workspaces through
+   * the Actor model. Authentication for profiles is handled via SSO/OAuth (WorkOS).
+   */
+  createdBy?: AccountAPI.Profile;
+
+  /**
+   * Lifecycle state. Transitions PENDING → COMPLETE (storage confirms the object
+   * exists) → CONSUMED (a resource referenced this upload), or → EXPIRED (URL
+   * elapsed without a PUT).
+   */
+  status?:
+    | 'UPLOAD_STATUS_UNSPECIFIED'
+    | 'UPLOAD_STATUS_PENDING'
+    | 'UPLOAD_STATUS_COMPLETE'
+    | 'UPLOAD_STATUS_CONSUMED'
+    | 'UPLOAD_STATUS_EXPIRED';
+
+  /**
+   * Presigned PUT URL. Short-lived. The client must PUT with the exact Content-Type
+   * declared in the spec, and the body length must match size_bytes.
+   */
+  uploadUrl?: string;
+
+  /**
+   * Absolute time at which upload_url stops working.
+   */
+  uploadUrlExpiresAt?: string;
+}
+
+export interface UploadSpec {
+  /**
+   * MIME type the client will send. Baked into the presigned URL's signature — the
+   * PUT must match exactly or object storage will reject it.
+   */
+  contentType: string;
+
+  /**
+   * Client-supplied filename. Used for audit and display only; does not control the
+   * object's storage path.
+   */
+  filename: string;
+
+  /**
+   * Expected size of the upload in bytes. Baked into the presigned URL as a
+   * Content-Length constraint.
+   */
+  sizeBytes: string;
+}
+
+export interface UploadCreateParams {
+  /**
+   * CreateResourceMetadata contains the user-provided fields for creating a
+   * workspace-scoped resource. Read-only fields (id, account_id, workspace_id,
+   * profile_id, created_at) are excluded since they are set by the server.
+   */
+  metadata: Shared.CreateResourceMetadata;
+
+  spec: UploadSpec;
+}
+
+export declare namespace Uploads {
+  export {
+    type Upload as Upload,
+    type UploadInfo as UploadInfo,
+    type UploadSpec as UploadSpec,
+    type UploadCreateParams as UploadCreateParams,
+  };
+}

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.44.0'; // x-release-please-version
+export const VERSION = '0.46.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.44.0";
+export declare const VERSION = "0.46.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.44.0";
+export declare const VERSION = "0.46.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.44.0'; // x-release-please-version
+exports.VERSION = '0.46.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.44.0'; // x-release-please-version
+export const VERSION = '0.46.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map