Add missing types

libs/sdk-js/.gitignore

@@ -6,6 +6,10 @@ client.cjs
 client.js
 client.d.ts
 client.d.cts
+auth.cjs
+auth.js
+auth.d.ts
+auth.d.cts
 react.cjs
 react.js
 react.d.ts

libs/sdk-js/package.json

@@ -72,6 +72,15 @@
       "import": "./client.js",
       "require": "./client.cjs"
     },
+    "./auth": {
+      "types": {
+        "import": "./auth.d.ts",
+        "require": "./auth.d.cts",
+        "default": "./auth.d.ts"
+      },
+      "import": "./auth.js",
+      "require": "./auth.cjs"
+    },
     "./react": {
       "types": {
         "import": "./react.d.ts",
@@ -111,6 +120,10 @@
     "client.js",
     "client.d.ts",
     "client.d.cts",
+    "auth.cjs",
+    "auth.js",
+    "auth.d.ts",
+    "auth.d.cts",
     "react.cjs",
     "react.js",
     "react.d.ts",

libs/sdk-js/src/auth/index.ts

@@ -5,10 +5,9 @@ interface AssistantConfig {
   recursion_limit?: Maybe<number>;
   configurable?: Maybe<{
     thread_id?: Maybe<string>;
-    thread_ts?: Maybe<number>;
+    thread_ts?: Maybe<string>;
     [key: string]: unknown;
   }>;
-  [key: string]: unknown;
 }
 
 interface AssistantCreate {
@@ -24,7 +23,6 @@ interface AssistantRead {
   assistant_id: string;
   metadata?: Maybe<Record<string, unknown>>;
 }
-
 interface AssistantUpdate {
   assistant_id: string;
   metadata?: Maybe<Record<string, unknown>>;
@@ -33,11 +31,9 @@ interface AssistantUpdate {
   name?: Maybe<string>;
   version?: Maybe<number>;
 }
-
 interface AssistantDelete {
   assistant_id: string;
 }
-
 interface AssistantSearch {
   graph_id?: Maybe<string>;
   metadata?: Maybe<Record<string, unknown>>;
@@ -45,28 +41,114 @@ interface AssistantSearch {
   offset?: Maybe<number>;
 }
 
-// TODO: add missing types
-interface ThreadCreate {}
-interface ThreadRead {}
-interface ThreadUpdate {}
-interface ThreadDelete {}
-interface ThreadSearch {}
+interface ThreadCreate {
+  thread_id?: Maybe<string>;
+  metadata?: Maybe<Record<string, unknown>>;
+  if_exists?: Maybe<"raise" | "do_nothing">;
+}
 
-interface CronCreate {}
-interface CronRead {}
-interface CronUpdate {}
-interface CronDelete {}
-interface CronSearch {}
+interface ThreadRead {
+  thread_id?: Maybe<string>;
+}
 
-interface StorePut {}
-interface StoreGet {}
-interface StoreSearch {}
-interface StoreListNamespaces {}
-interface StoreDelete {}
+interface ThreadUpdate {
+  thread_id?: Maybe<string>;
+  metadata?: Maybe<Record<string, unknown>>;
+  action?: Maybe<"interrupt" | "rollback">;
+}
 
-interface RunsCreate {}
+interface ThreadDelete {
+  thread_id?: Maybe<string>;
+  run_id?: Maybe<string>;
+}
 
-interface ResourceActionType {
+interface ThreadSearch {
+  thread_id?: Maybe<string>;
+  status?: Maybe<"idle" | "busy" | "interrupted" | "error" | (string & {})>;
+  metadata?: Maybe<Record<string, unknown>>;
+  values?: Maybe<Record<string, unknown>>;
+  limit?: Maybe<number>;
+  offset?: Maybe<number>;
+}
+
+interface CronCreate {
+  payload?: Maybe<Record<string, unknown>>;
+  schedule: string;
+  cron_id?: Maybe<string>;
+  thread_id?: Maybe<string>;
+  user_id?: Maybe<string>;
+  end_time?: Maybe<string>;
+}
+
+interface CronRead {
+  cron_id: string;
+}
+
+interface CronUpdate {
+  cron_id: string;
+  payload?: Maybe<Record<string, unknown>>;
+  schedule?: Maybe<string>;
+}
+
+interface CronDelete {
+  cron_id: string;
+}
+
+interface CronSearch {
+  assistant_id?: Maybe<string>;
+  thread_id?: Maybe<string>;
+  limit?: Maybe<number>;
+  offset?: Maybe<number>;
+}
+
+interface StorePut {
+  namespace: string[];
+  key: string;
+  value: Record<string, unknown>;
+}
+
+interface StoreGet {
+  namespace: Maybe<string[]>;
+  key: string;
+}
+
+interface StoreSearch {
+  namespace?: Maybe<string[]>;
+  filter?: Maybe<Record<string, unknown>>;
+  limit?: Maybe<number>;
+  offset?: Maybe<number>;
+  query?: Maybe<string>;
+}
+
+interface StoreListNamespaces {
+  namespace?: Maybe<string[]>;
+  suffix?: Maybe<string[]>;
+  max_depth?: Maybe<number>;
+  limit?: Maybe<number>;
+  offset?: Maybe<number>;
+}
+
+interface StoreDelete {
+  namespace?: Maybe<string[]>;
+  key: string;
+}
+
+interface RunsCreate {
+  thread_id?: Maybe<string>;
+  assistant_id: string;
+  run_id: string;
+  status: Maybe<
+    "pending" | "running" | "error" | "success" | "timeout" | "interrupted"
+  >;
+  metadata?: Maybe<Record<string, unknown>>;
+  prevent_insert_if_inflight?: Maybe<boolean>;
+  multitask_strategy?: Maybe<"interrupt" | "rollback" | "reject" | "enqueue">;
+  if_not_exists?: Maybe<"reject" | "create">;
+  after_seconds?: Maybe<number>;
+  kwargs: Record<string, unknown>;
+}
+
+export interface ResourceActionType {
   ["threads:create"]: ThreadCreate;
   ["threads:read"]: ThreadRead;
   ["threads:update"]: ThreadUpdate;
@@ -187,7 +269,7 @@ type ResourceCallbackParameter<
   AuthContext = {},
 > = ContextMap[ResourceType[T]] & { context: AuthContext };
 
-type Filters<TKey extends string | number | symbol = string> = {
+export type Filters<TKey extends string | number | symbol = string> = {
   [key in TKey]: string | { [op in "$contains" | "$eq"]?: string };
 };
 
@@ -195,12 +277,46 @@ interface AuthenticateCallback<AuthContext extends Record<string, unknown>> {
   (request: Request): AuthContext;
 }
 
+interface GlobalCallback<
+  Metadata extends Record<string, unknown> = {},
+  AuthContext extends Record<string, unknown> = {},
+> {
+  (
+    data: AuthCallbackParameter<keyof ResourceActionType, AuthContext>,
+  ): void | boolean | Filters<keyof Metadata>;
+}
+
+interface ResourceCallback<
+  Metadata extends Record<string, unknown> = {},
+  AuthContext extends Record<string, unknown> = {},
+> {
+  (
+    data: ResourceCallbackParameter<keyof ResourceType, AuthContext>,
+  ): void | boolean | Filters<keyof Metadata>;
+}
+
+interface ActionCallback<
+  Metadata extends Record<string, unknown> = {},
+  AuthContext extends Record<string, unknown> = {},
+> {
+  (
+    data: ActionCallbackParameter<keyof ActionType, AuthContext>,
+  ): void | boolean | Filters<keyof Metadata>;
+}
+
+interface ResourceActionCallback<
+  Metadata extends Record<string, unknown> = {},
+  AuthContext extends Record<string, unknown> = {},
+> {
+  (
+    data: AuthCallbackParameter<keyof ResourceActionType, AuthContext>,
+  ): void | boolean | Filters<keyof Metadata>;
+}
+
 export class Auth<
   Metadata extends Record<string, unknown> = {},
   AuthContext extends Record<string, unknown> = {},
 > {
-  protected __lg_type = Symbol.for("lg:auth");
-
   "~handlerCache": {
     authenticate?: AuthenticateCallback<AuthContext>;
     callbacks?: Record<
@@ -217,21 +333,14 @@ export class Auth<
   /**
    * Global handler for all requests
    */
-  on(
-    event: "*",
-    callback: (
-      data: AuthCallbackParameter<keyof ResourceActionType>,
-    ) => void | boolean | Filters<keyof Metadata>,
-  ): this;
+  on(event: "*", callback: GlobalCallback): this;
 
   /**
    * Resource-specific handler
    */
   on<T extends keyof ResourceType>(
     event: T,
-    callback: (
-      data: ResourceCallbackParameter<T, AuthContext>,
-    ) => void | boolean | Filters<keyof Metadata>,
+    callback: ResourceCallback<Metadata, AuthContext>,
   ): this;
 
   /**
@@ -239,9 +348,7 @@ export class Auth<
    */
   on<T extends keyof ActionType>(
     event: T,
-    callback: (
-      data: ActionCallbackParameter<T, AuthContext>,
-    ) => void | boolean | Filters<keyof Metadata>,
+    callback: ActionCallback<Metadata, AuthContext>,
   ): this;
 
   /**
@@ -249,9 +356,7 @@ export class Auth<
    */
   on<T extends keyof ResourceActionType>(
     event: T,
-    callback: (
-      data: AuthCallbackParameter<T, AuthContext>,
-    ) => void | boolean | Filters<keyof Metadata>,
+    callback: ResourceActionCallback,
   ): this;
 
   on(