@wildix/wilma-copilot-sessions-client 1.0.5 → 1.0.6

package/dist-types/commands/{StreamCopilotSessionEventsCommand.d.ts → StreamSessionEventsCommand.d.ts}

@@ -1,6 +1,6 @@
 import { Command as $Command } from "@smithy/core/client";
 import type { MetadataBearer as __MetadataBearer, StreamingBlobPayloadOutputTypes } from "@smithy/types";
-import type { StreamCopilotSessionEventsInput, StreamCopilotSessionEventsOutput } from "../models/models_0";
+import type { StreamSessionEventsInput, StreamSessionEventsOutput } from "../models/models_0";
 import type { ServiceInputTypes, ServiceOutputTypes, WilmaCopilotSessionsClientResolvedConfig } from "../WilmaCopilotSessionsClient";
 /**
  * @public
@@ -10,56 +10,56 @@ export { $Command };
 /**
  * @public
  *
- * The input for {@link StreamCopilotSessionEventsCommand}.
+ * The input for {@link StreamSessionEventsCommand}.
  */
-export interface StreamCopilotSessionEventsCommandInput extends StreamCopilotSessionEventsInput {
+export interface StreamSessionEventsCommandInput extends StreamSessionEventsInput {
 }
 /**
  * @public
  *
- * The output of {@link StreamCopilotSessionEventsCommand}.
+ * The output of {@link StreamSessionEventsCommand}.
  */
-export interface StreamCopilotSessionEventsCommandOutput extends Omit<StreamCopilotSessionEventsOutput, "events">, __MetadataBearer {
+export interface StreamSessionEventsCommandOutput extends Omit<StreamSessionEventsOutput, "events">, __MetadataBearer {
     events: StreamingBlobPayloadOutputTypes;
 }
-declare const StreamCopilotSessionEventsCommand_base: {
-    new (input: StreamCopilotSessionEventsCommandInput): import("@smithy/core/client").CommandImpl<StreamCopilotSessionEventsCommandInput, StreamCopilotSessionEventsCommandOutput, WilmaCopilotSessionsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
-    new (input: StreamCopilotSessionEventsCommandInput): import("@smithy/core/client").CommandImpl<StreamCopilotSessionEventsCommandInput, StreamCopilotSessionEventsCommandOutput, WilmaCopilotSessionsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+declare const StreamSessionEventsCommand_base: {
+    new (input: StreamSessionEventsCommandInput): import("@smithy/core/client").CommandImpl<StreamSessionEventsCommandInput, StreamSessionEventsCommandOutput, WilmaCopilotSessionsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: StreamSessionEventsCommandInput): import("@smithy/core/client").CommandImpl<StreamSessionEventsCommandInput, StreamSessionEventsCommandOutput, WilmaCopilotSessionsClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
     getEndpointParameterInstructions(): import("@smithy/types").EndpointParameterInstructions;
 };
 /**
- * Replays and tails copilot session events as Server-Sent Events (`text/event-stream`). Each frame carries one CopilotSessionEvent: `id:` is the event index, `event:` is the union member name, and `data:` is the JSON document of the union value. Reconnect by passing the last seen index + 1 as `startIndex`. The stream ends after a terminal `lifecycle` event (`ended`, `stopped` or `failed`); for finished sessions the recorded events are replayed and the stream closes.
+ * Replays and tails copilot session events as Server-Sent Events (`text/event-stream`). Each frame carries one CopilotSessionEvent: `id:` is the event index, `event:` is the union member name, and `data:` is the JSON document of the union value. Reconnect by passing the last seen index + 1 as `startIndex`. The stream closes after a `lifecycle` event that leaves the session dormant (`idle`, `archived`) or `failed`. Dormant sessions can revive on a later event — reconnect with the last seen index + 1 to continue; for dormant sessions the recorded events are replayed and the stream closes.
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
- * import { WilmaCopilotSessionsClient, StreamCopilotSessionEventsCommand } from "@wildix/wilma-copilot-sessions-client"; // ES Modules import
- * // const { WilmaCopilotSessionsClient, StreamCopilotSessionEventsCommand } = require("@wildix/wilma-copilot-sessions-client"); // CommonJS import
+ * import { WilmaCopilotSessionsClient, StreamSessionEventsCommand } from "@wildix/wilma-copilot-sessions-client"; // ES Modules import
+ * // const { WilmaCopilotSessionsClient, StreamSessionEventsCommand } = require("@wildix/wilma-copilot-sessions-client"); // CommonJS import
  * // import type { WilmaCopilotSessionsClientConfig } from "@wildix/wilma-copilot-sessions-client";
  * const config = {}; // type is WilmaCopilotSessionsClientConfig
  * const client = new WilmaCopilotSessionsClient(config);
- * const input = { // StreamCopilotSessionEventsInput
+ * const input = { // StreamSessionEventsInput
  *   sessionId: "STRING_VALUE", // required
  *   company: "STRING_VALUE",
  *   startIndex: Number("int"),
  * };
- * const command = new StreamCopilotSessionEventsCommand(input);
+ * const command = new StreamSessionEventsCommand(input);
  * const response = await client.send(command);
  * // consume or destroy the stream to free the socket.
  * const bytes = await response.events.transformToByteArray();
  * // const str = await response.events.transformToString();
  * // response.events.destroy(); // only applicable to Node.js Readable streams.
  *
- * // { // StreamCopilotSessionEventsOutput
+ * // { // StreamSessionEventsOutput
  * //   events: "<SdkStream>", // see \@smithy/types -> StreamingBlobPayloadOutputTypes // required
  * //   contentType: "STRING_VALUE", // required
  * // };
  *
  * ```
  *
- * @param StreamCopilotSessionEventsCommandInput - {@link StreamCopilotSessionEventsCommandInput}
- * @returns {@link StreamCopilotSessionEventsCommandOutput}
- * @see {@link StreamCopilotSessionEventsCommandInput} for command's `input` shape.
- * @see {@link StreamCopilotSessionEventsCommandOutput} for command's `response` shape.
+ * @param StreamSessionEventsCommandInput - {@link StreamSessionEventsCommandInput}
+ * @returns {@link StreamSessionEventsCommandOutput}
+ * @see {@link StreamSessionEventsCommandInput} for command's `input` shape.
+ * @see {@link StreamSessionEventsCommandOutput} for command's `response` shape.
  * @see {@link WilmaCopilotSessionsClientResolvedConfig | config} for WilmaCopilotSessionsClient's `config` shape.
  *
  * @throws {@link ValidationException} (client fault)
@@ -74,16 +74,16 @@ declare const StreamCopilotSessionEventsCommand_base: {
  *
  * @public
  */
-export declare class StreamCopilotSessionEventsCommand extends StreamCopilotSessionEventsCommand_base {
+export declare class StreamSessionEventsCommand extends StreamSessionEventsCommand_base {
     /** @internal type navigation helper, not in runtime. */
     protected static __types: {
         api: {
-            input: StreamCopilotSessionEventsInput;
-            output: StreamCopilotSessionEventsOutput;
+            input: StreamSessionEventsInput;
+            output: StreamSessionEventsOutput;
         };
         sdk: {
-            input: StreamCopilotSessionEventsCommandInput;
-            output: StreamCopilotSessionEventsCommandOutput;
+            input: StreamSessionEventsCommandInput;
+            output: StreamSessionEventsCommandOutput;
         };
     };
 }

package/dist-types/commands/index.d.ts

@@ -1,2 +1,7 @@
-export * from "./GetCopilotSessionEventsCommand";
-export * from "./StreamCopilotSessionEventsCommand";
+export * from "./AskCommand";
+export * from "./EnrichCommand";
+export * from "./GetSessionEventsCommand";
+export * from "./ListSessionsCommand";
+export * from "./OpenCommand";
+export * from "./ResolveCommand";
+export * from "./StreamSessionEventsCommand";

package/dist-types/index.d.ts

@@ -10,6 +10,12 @@
  *     lives in the companion wilma-copilot service; this service applies the published profile
  *     versions and streams what copilot detects and shows.
  *
+ *     Client surfaces additionally push context events (Open): emails, phones and
+ *     typed entity references resolved into a relationship — the durable cross-channel view of one
+ *     customer. Sessions never close: they idle when the conversation ends or goes quiet, archive to
+ *     cold storage later, and revive on any new event. A new conversation gets a new session linked
+ *     to the same relationship; the ingest response returns the sessions already associated with it.
+ *
  * @packageDocumentation
  */
 export * from "./WilmaCopilotSessionsClient";

package/dist-types/models/enums.d.ts

@@ -247,27 +247,100 @@ export declare const AssetSeverity: {
  * @public
  */
 export type AssetSeverity = (typeof AssetSeverity)[keyof typeof AssetSeverity];
+/**
+ * @public
+ * @enum
+ */
+export declare const CopilotConversationKind: {
+    /**
+     * A copilot session opened directly from the app, without an underlying call, chat or conference. The conversation id is server-minted.
+     */
+    readonly APP: "app";
+    readonly CALL: "call";
+    readonly CHAT: "chat";
+    readonly CONFERENCE: "conference";
+};
+/**
+ * @public
+ */
+export type CopilotConversationKind = (typeof CopilotConversationKind)[keyof typeof CopilotConversationKind];
+/**
+ * @public
+ * @enum
+ */
+export declare const CopilotIngestedSessionState: {
+    /**
+     * A new session was created for the event's conversation.
+     */
+    readonly CREATED: "created";
+    /**
+     * An existing session for the same conversation accepted the event; idle or archived sessions revive.
+     */
+    readonly REUSED: "reused";
+};
+/**
+ * @public
+ */
+export type CopilotIngestedSessionState = (typeof CopilotIngestedSessionState)[keyof typeof CopilotIngestedSessionState];
+/**
+ * @public
+ * @enum
+ */
+export declare const CopilotLifecycleReason: {
+    /**
+     * The archive timer moved the idle session's state to cold storage.
+     */
+    readonly ARCHIVE_TIMER: "archive_timer";
+    /**
+     * The session was created — a matching conversation started or context was ingested for one.
+     */
+    readonly CREATED: "created";
+    /**
+     * The conversation ended; the session idles and stays revivable.
+     */
+    readonly ENDED: "ended";
+    /**
+     * An unrecoverable processing error.
+     */
+    readonly ERROR: "error";
+    /**
+     * No events arrived within the inactivity window; the session idles.
+     */
+    readonly INACTIVITY: "inactivity";
+    /**
+     * A new event revived an idle or archived session.
+     */
+    readonly REVIVED: "revived";
+    /**
+     * Assistance was stopped before the conversation ended; the session idles.
+     */
+    readonly STOPPED: "stopped";
+};
+/**
+ * @public
+ */
+export type CopilotLifecycleReason = (typeof CopilotLifecycleReason)[keyof typeof CopilotLifecycleReason];
 /**
  * @public
  * @enum
  */
 export declare const CopilotSessionStatus: {
     /**
-     * The conversation is live and being assisted.
+     * The session is processing events for its conversation.
      */
     readonly ACTIVE: "active";
     /**
-     * The conversation ended normally.
+     * Session state moved to cold storage. A new event rehydrates and revives the session.
      */
-    readonly ENDED: "ended";
+    readonly ARCHIVED: "archived";
     /**
-     * Assistance failed with an unrecoverable error.
+     * Assistance failed with an unrecoverable error. The only terminal status.
      */
     readonly FAILED: "failed";
     /**
-     * Assistance was stopped before the conversation ended.
+     * The conversation ended or went quiet. State is kept; any new event revives the session instantly.
      */
-    readonly STOPPED: "stopped";
+    readonly IDLE: "idle";
 };
 /**
  * @public