@slates/client 1.0.0-rc.2 → 1.0.0-rc.6

package/dist/index.d.cts

@@ -306,6 +306,7 @@ declare class SlatesProtocolClient {
                 id: string;
                 title: string;
                 description?: string | undefined;
+                defaultChecked?: boolean | undefined;
             }[] | undefined;
         };
     }>;
@@ -543,6 +544,17 @@ declare class SlatesProtocolClient {
     invokeTool(actionId: string, input: Record<string, any>): Promise<{
         output: Record<string, any>;
         message?: string | undefined;
+        attachments?: {
+            content: {
+                type: "url";
+                url: string;
+            } | {
+                type: "content";
+                encoding: "base64" | "utf-8";
+                content: string;
+            };
+            mimeType?: string | undefined;
+        }[] | undefined;
         requestTraces?: {
             startedAt: string;
             durationMs: number;
@@ -726,6 +738,7 @@ interface SlateProtocolErrorResponse {
     provider?: Record<string, unknown>;
     upstream?: Record<string, unknown>;
     baggage?: Record<string, unknown>;
+    requestTraces?: Array<Record<string, unknown>>;
     [key: string]: unknown;
 }
 declare class SlateProtocolError extends Error {
@@ -748,6 +761,7 @@ declare class SlateProtocolError extends Error {
         provider?: Record<string, unknown>;
         upstream?: Record<string, unknown>;
         baggage?: Record<string, unknown>;
+        requestTraces?: Array<Record<string, unknown>>;
     };
     static is(error: unknown): error is SlateProtocolError;
     static fromResponse(error: unknown, source?: SlateProtocolErrorSource): SlateProtocolError;

package/dist/index.d.ts

@@ -306,6 +306,7 @@ declare class SlatesProtocolClient {
                 id: string;
                 title: string;
                 description?: string | undefined;
+                defaultChecked?: boolean | undefined;
             }[] | undefined;
         };
     }>;
@@ -543,6 +544,17 @@ declare class SlatesProtocolClient {
     invokeTool(actionId: string, input: Record<string, any>): Promise<{
         output: Record<string, any>;
         message?: string | undefined;
+        attachments?: {
+            content: {
+                type: "url";
+                url: string;
+            } | {
+                type: "content";
+                encoding: "base64" | "utf-8";
+                content: string;
+            };
+            mimeType?: string | undefined;
+        }[] | undefined;
         requestTraces?: {
             startedAt: string;
             durationMs: number;
@@ -726,6 +738,7 @@ interface SlateProtocolErrorResponse {
     provider?: Record<string, unknown>;
     upstream?: Record<string, unknown>;
     baggage?: Record<string, unknown>;
+    requestTraces?: Array<Record<string, unknown>>;
     [key: string]: unknown;
 }
 declare class SlateProtocolError extends Error {
@@ -748,6 +761,7 @@ declare class SlateProtocolError extends Error {
         provider?: Record<string, unknown>;
         upstream?: Record<string, unknown>;
         baggage?: Record<string, unknown>;
+        requestTraces?: Array<Record<string, unknown>>;
     };
     static is(error: unknown): error is SlateProtocolError;
     static fromResponse(error: unknown, source?: SlateProtocolErrorSource): SlateProtocolError;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slates/client",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.0-rc.6",
   "publishConfig": {
     "access": "public"
   },
@@ -31,9 +31,9 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@slates/proto": "1.0.0-rc.7",
-    "@slates/provider": "1.0.0-rc.8",
-    "@slates/provider-handler": "1.0.0-rc.7"
+    "@slates/proto": "1.0.0-rc.8",
+    "@slates/provider": "1.0.0-rc.10",
+    "@slates/provider-handler": "1.0.0-rc.9"
   },
   "devDependencies": {
     "@slates/tsconfig": "1.0.0-rc.1",

package/src/client.test.ts

@@ -170,6 +170,59 @@ let createTraceSlate = (baseUrl: string) => {
   });
 };
 
+let createTraceErrorSlate = (baseUrl: string) => {
+  let config = SlateConfig.create(z.object({}));
+  let auth = SlateAuth.create<{}>().output(z.object({}));
+
+  let spec = SlateSpecification.create({
+    key: 'trace-error-slate',
+    name: 'Trace Error Slate',
+    description: 'A slate that traces failed HTTP requests',
+    config,
+    auth
+  });
+
+  let traceTool = SlateTool.create(spec, {
+    key: 'trace_http_error',
+    name: 'Trace HTTP Error'
+  })
+    .input(z.object({}))
+    .output(
+      z.object({
+        ok: z.boolean()
+      })
+    )
+    .handleInvocation(async () => {
+      await axios.post(
+        `${baseUrl}/trace-error?client_secret=request-secret`,
+        new URLSearchParams({
+          grant_type: 'authorization_code',
+          client_secret: 'client-secret'
+        }).toString(),
+        {
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: 'Bearer client-token'
+          }
+        }
+      );
+
+      return {
+        output: {
+          ok: true
+        },
+        message: 'should not reach'
+      };
+    })
+    .build();
+
+  return Slate.create({
+    spec,
+    tools: [traceTool],
+    triggers: []
+  });
+};
+
 let createTriggerTraceSlate = () => {
   let config = SlateConfig.create(z.object({}));
   let auth = SlateAuth.create<{}>().output(z.object({}));
@@ -566,4 +619,56 @@ describe('@slates/client local transport', () => {
       });
     }
   });
+
+  it('returns sanitized request traces on provider errors', async () => {
+    let server = createServer((_req, res) => {
+      res.statusCode = 400;
+      res.setHeader('Content-Type', 'application/json');
+      res.end(
+        JSON.stringify({
+          error: 'invalid_grant',
+          client_secret: 'server-secret'
+        })
+      );
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      server.once('error', reject);
+      server.listen(0, '127.0.0.1', () => resolve());
+    });
+
+    try {
+      let { port } = server.address() as AddressInfo;
+      let client = createSlatesClient({
+        transport: createLocalSlateTransport({
+          slate: createTraceErrorSlate(`http://127.0.0.1:${port}`)
+        }),
+        state: {
+          config: {}
+        }
+      });
+
+      let error = await client
+        .invokeTool('trace_http_error', {})
+        .then(() => null)
+        .catch(err => err as SlateProtocolError);
+
+      expect(error).toBeInstanceOf(SlateProtocolError);
+      expect(error?.data.code).toBe('upstream.invalid_request');
+      expect(error?.data.requestTraces).toHaveLength(1);
+
+      let trace = error?.data.requestTraces?.[0] as Record<string, any> | undefined;
+      expect(trace?.request.method).toBe('POST');
+      expect(trace?.request.url).not.toContain('request-secret');
+      expect(trace?.request.headers).not.toHaveProperty('authorization');
+      expect(trace?.request.body?.text).toContain('client_secret=[redacted]');
+      expect(trace?.response?.status).toBe(400);
+      expect(trace?.response?.body?.text).toContain('"client_secret":"[redacted]"');
+      expect(trace?.response?.body?.text).not.toContain('server-secret');
+    } finally {
+      await new Promise<void>((resolve, reject) => {
+        server.close(error => (error ? reject(error) : resolve()));
+      });
+    }
+  });
 });

package/src/error.ts

@@ -22,6 +22,7 @@ export interface SlateProtocolErrorResponse {
   provider?: Record<string, unknown>;
   upstream?: Record<string, unknown>;
   baggage?: Record<string, unknown>;
+  requestTraces?: Array<Record<string, unknown>>;
   [key: string]: unknown;
 }