@yaklabs-ai/plugin-sdk 0.48.0 → 0.49.0

package/dist/kay-app.d.ts

@@ -830,6 +830,12 @@ declare function ConstructorParameters_2<Type extends TSchema>(type: Type, optio
 /** Creates a deferred ConstructorParameters action. */
 declare function ConstructorParametersDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TConstructorParametersDeferred<Type>;
 
+/**
+ * Stable digest of a read's content, the revision a module without one gets.
+ * Prefixed so a provider revision can never collide with it by accident.
+ */
+export declare function contentDigest(content: string | Uint8Array): string;
+
 export declare interface CorpusResourceInvocation {
     readonly eventId: string;
     /** Envelope recording time, never a run/message/incident identifier. */
@@ -964,6 +970,8 @@ export declare function createUnavailableSkills(message: string): KayAppSkills;
  */
 export declare function createUnavailableTools(): KayAppTools;
 
+export declare function createUnavailableUriCaller(message: string): PluginUriCaller;
+
 /**
  * A `KayAppUsage` that answers `unavailable` to every call: what a host with no telemetry lane
  * binds, so `app.usage` stays present on every host.
@@ -1139,6 +1147,9 @@ declare interface Decision<Q extends DecideQuestions = DecideQuestions> {
     readonly usage?: SystemOneTokenUsage;
 }
 
+/** Builds an app tool from manifest facts, retaining its execution, availability and preview callbacks. */
+export declare function declaredAppToolDefinition(tool: ToolContribution, implementation: KayAppToolImplementation): KayAppToolDefinition;
+
 /** Createsa  uni-directional Codec with Decode only. The Decode function is called on Value.Decode */
 declare function Decode<Type extends TSchema, Callback extends TDecodeCallback<StaticDecode<Type>, unknown>>(type: Type, callback: Callback): TCodec<Type, ReturnType<Callback>>;
 
@@ -2882,8 +2893,15 @@ declare const KAY_PLUGIN_PROTOCOL_VERSION: "kay.plugin.v1";
  * 0.47.0 adds card layouts and builders; successful card submits now require a summary.
  *
  * 0.48.0 adds the models.complete UI capability.
+ *
+ * 0.48.1 adds app-tool metadata, conditional tool permissions and screen-action declarations.
+ *
+ * 0.49.0 adds sessionless URI calls on both backend targets. It removes app.memory and its note
+ * types; callers use the resource surface instead. Previously admitted SDK contracts are no
+ * longer served because they included app.memory on notebook hosts. No compatibility alias
+ * restores it; callers migrate and declare ^0.49.0.
  */
-declare const KAY_PLUGIN_SDK_VERSION: "0.48.0";
+declare const KAY_PLUGIN_SDK_VERSION: "0.49.0";
 
 declare const KAY_PLUGIN_TARGET_NAMES: readonly ["kay.agent", "kay.app", "kay.ui"];
 
@@ -4823,60 +4841,6 @@ export declare interface KayAppMcp {
     }): Promise<VendoredMcpOutcome>;
 }
 
-/**
- * Notes through Memory's ordinary notebook operations, without a chat session. Each call checks
- * `memory.read` or `memory.write`; a missing notebook or refused grant rejects. Paths are note
- * addresses such as `facts/this-computer`, without the `memory://` scheme.
- */
-export declare interface KayAppMemory {
-    read(path: string): Promise<KayAppMemoryNote | undefined>;
-    /** Create a note; an existing address is a conflict. */
-    create(path: string, input: KayAppMemoryNoteInput, options?: {
-        readonly signal?: AbortSignal;
-    }): Promise<void>;
-    /** Edit only the revision returned by `read`; concurrent changes reject as a conflict. */
-    edit(path: string, input: KayAppMemoryNoteEdit, options: {
-        readonly expectedRevision: string;
-    }): Promise<void>;
-}
-
-export declare interface KayAppMemoryNote {
-    readonly name: string;
-    readonly description: string;
-    readonly body: string;
-    readonly frontmatter: Readonly<Record<string, unknown>> | undefined;
-    readonly revision: string;
-}
-
-export declare interface KayAppMemoryNoteEdit {
-    readonly frontmatter?: {
-        readonly name?: string;
-        readonly description?: string;
-    };
-    readonly body?: {
-        readonly replace: string;
-    } | {
-        readonly edits: readonly {
-            readonly oldText: string;
-            readonly newText: string;
-        }[];
-    };
-}
-
-export declare interface KayAppMemoryNoteInput {
-    readonly name: string;
-    readonly description: string;
-    readonly body: string;
-    readonly sources?: readonly KayAppMemoryNoteSource[];
-}
-
-export declare interface KayAppMemoryNoteSource {
-    readonly id: string;
-    readonly uri: string;
-    readonly kind?: "user" | "source";
-    readonly at?: string;
-}
-
 /** Input to one bounded direct model completion with no transcript or tools. */
 export declare interface KayAppModelCompleteInput {
     /** Attribution slug (`^[a-z][a-z0-9-]*$`) naming what this call is for. */
@@ -5489,8 +5453,7 @@ export declare interface KayAppPluginApi {
      * present, like {@link signals}.
      */
     readonly skills: KayAppSkills;
-    /** Memory note operations; absent when this host has no notebook composition. */
-    readonly memory?: KayAppMemory;
+    readonly uri: PluginUriCaller;
     /**
      * Private API: only plugins Bonsai ships; refused for any other. The assistant's personality
      * file, each call checked against `soul.write`. Absent when the host composed no soul store.
@@ -7862,6 +7825,10 @@ export declare interface KayAppToolEvents {
     subscribe(handler: (event: unknown) => void): () => void;
 }
 
+export declare type KayAppToolImplementation = Omit<KayAppToolDefinition, "label" | "description" | "parameters" | "permission" | "executionMode" | "promptSnippet" | "promptGuidelines"> & {
+    readonly permission?: Pick<ToolPermissionHint, "describePreview">;
+};
+
 /** Where a described tool or address comes from. */
 export declare type KayAppToolOrigin = 
 /** The agent kernel's own (`bash`, `read`, `help`, `skill://`). */
@@ -10169,6 +10136,38 @@ declare const PluginToolName: z.ZodString;
 
 declare type PluginToolName = z.infer<typeof PluginToolName>;
 
+/**
+ * Sessionless resource calls. Each call checks the calling target's exact scheme and verb grant.
+ * Results retain provider bytes, metadata and revisions; provider failures retain their URI tags.
+ * A cancellation or lost response does not prove a mutation was not applied.
+ */
+export declare interface PluginUriCaller {
+    read(input: string, options?: PluginUriReadOptions): Promise<RawResource>;
+    list(input: string, params?: UriListParams, options?: PluginUriCallOptions): Promise<UriListResult>;
+    search(input: string, params: UriSearchParams, options?: PluginUriCallOptions): Promise<UriSearchResult>;
+    write(input: string, content?: UriPayload | Uint8Array, options?: PluginUriWriteOptions): Promise<UriMutationResult | void>;
+    edit(input: string, payload: UriPayload, options?: PluginUriMutationOptions): Promise<UriMutationResult>;
+    delete(input: string, options?: PluginUriMutationOptions): Promise<UriMutationResult>;
+}
+
+export declare interface PluginUriCallOptions {
+    readonly cwd?: string;
+    readonly signal?: AbortSignal;
+}
+
+export declare interface PluginUriMutationOptions extends PluginUriCallOptions {
+    readonly expectedRevision?: string;
+}
+
+export declare interface PluginUriReadOptions extends PluginUriCallOptions {
+    readonly knownRevision?: string;
+}
+
+export declare interface PluginUriWriteOptions extends PluginUriMutationOptions {
+    readonly sources?: readonly UriWriteSource[];
+    readonly writeSource?: UriSourceDescriptor;
+}
+
 export declare interface PreparedAccessApproval {
     readonly uri: string;
     readonly content: Record<string, unknown>;
@@ -14200,6 +14199,56 @@ declare interface ToolContext {
     readonly paths?: ExtensionPaths;
 }
 
+export declare const ToolContribution: z.ZodObject<{
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<authoringCommonSchemas.JsonValue, unknown, z.core.$ZodTypeInternals<authoringCommonSchemas.JsonValue, unknown>>>>;
+    executionMode: z.ZodOptional<z.ZodEnum<{
+        sequential: "sequential";
+        parallel: "parallel";
+    }>>;
+    promptSnippet: z.ZodOptional<z.ZodString>;
+    promptGuidelines: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    permission: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            read: "read";
+            mutate: "mutate";
+            destructive: "destructive";
+            execute: "execute";
+        }>;
+        ruleKey: z.ZodOptional<z.ZodString>;
+        scheme: z.ZodOptional<z.ZodString>;
+        resourcePrefix: z.ZodOptional<z.ZodString>;
+        resourceArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        resourceTrim: z.ZodOptional<z.ZodLiteral<true>>;
+        defaultPermission: z.ZodOptional<z.ZodEnum<{
+            never: "never";
+            allow: "allow";
+            ask: "ask";
+        }>>;
+        classificationRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                arg: z.ZodString;
+                equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
+            }, z.core.$strict>, z.ZodObject<{
+                arg: z.ZodString;
+                present: z.ZodBoolean;
+            }, z.core.$strict>]>>;
+            kind: z.ZodEnum<{
+                read: "read";
+                mutate: "mutate";
+                destructive: "destructive";
+                execute: "execute";
+            }>;
+            ruleKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    localId: z.ZodString;
+    toolName: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+
+export declare type ToolContribution = z.infer<typeof ToolContribution>;
+
 export declare interface ToolDefinition<TParams extends ToolParametersWire = ToolParametersWire, TDetails = unknown> {
     /** Tool name (used in LLM tool calls) */
     name: string;
@@ -16585,6 +16634,8 @@ declare interface UriResolveContext_2 {
      * resolve a URI outside any verb call.
      */
     readonly sessionId?: string;
+    /** Host-stamped calling plugin; absent for session dispatch and resolver matching. */
+    readonly callerPluginId?: string;
     /**
      * WHO the dispatching session acts as, stamped by the host at the same dispatch site as
      * {@link UriResolveContext.sessionId} and just as un-influenceable by the caller - so a module