agents 0.2.23 → 0.2.24

package/README.md

@@ -549,10 +549,12 @@ export class MyMCP extends McpAgent<Env, State, {}> {
       };
     });
 
-    this.server.tool(
+    this.server.registerTool(
       "add",
-      "Add to the counter, stored in the MCP",
-      { a: z.number() },
+      {
+        description: "Add to the counter, stored in the MCP",
+        inputSchema: { a: z.number() }
+      },
       async ({ a }) => {
         this.setState({ ...this.state, counter: this.state.counter + a });
 

package/dist/ai-chat-agent.d.ts

@@ -1,14 +1,9 @@
-import "./client-GfgZTqrS.js";
-import "./mcp-Dw5vDrY8.js";
-import "./do-oauth-client-provider-DGc5pP0l.js";
-import "./index-DhJCaDWd.js";
-import "./ai-types-D5YoPrBZ.js";
-import {
-  n as AgentContext,
-  s as Connection,
-  t as Agent,
-  x as WSMessage
-} from "./index-DEZFuVoU.js";
+import "./client-CsaP9Irq.js";
+import "./mcp-BwPscEiF.js";
+import "./do-oauth-client-provider-C2CHH5x-.js";
+import "./index-BUle9RiP.js";
+import "./ai-types-81H_-Uxh.js";
+import { n as AgentContext, t as Agent } from "./index-Bx5KK3VJ.js";
 import { StreamTextOnFinishCallback, ToolSet, UIMessage } from "ai";
 
 //#region src/ai-chat-agent.d.ts
@@ -25,12 +20,85 @@ declare class AIChatAgent<Env = unknown, State = unknown> extends Agent<
    * useful to propagate request cancellation signals for any external calls made by the agent
    */
   private _chatMessageAbortControllers;
+  /**
+   * Currently active stream ID for resumable streaming.
+   * Stored in memory for quick access; persisted in stream_metadata table.
+   */
+  private _activeStreamId;
+  /**
+   * Request ID associated with the active stream.
+   */
+  private _activeRequestId;
+  /**
+   * Current chunk index for the active stream
+   */
+  private _streamChunkIndex;
+  /**
+   * Buffer for stream chunks pending write to SQLite.
+   * Chunks are batched and flushed when buffer reaches CHUNK_BUFFER_SIZE.
+   */
+  private _chunkBuffer;
+  /**
+   * Lock to prevent concurrent flush operations
+   */
+  private _isFlushingChunks;
+  /**
+   * Timestamp of the last cleanup operation for old streams
+   */
+  private _lastCleanupTime;
   /** Array of chat messages for the current conversation */
   messages: UIMessage[];
   constructor(ctx: AgentContext, env: Env);
+  /**
+   * Restore active stream state if the agent was restarted during streaming.
+   * Called during construction to recover any interrupted streams.
+   * Validates stream freshness to avoid sending stale resume notifications.
+   */
+  private _restoreActiveStream;
+  /**
+   * Notify a connection about an active stream that can be resumed.
+   * The client should respond with CF_AGENT_STREAM_RESUME_ACK to receive chunks.
+   * Uses in-memory state for request ID - no extra DB lookup needed.
+   * @param connection - The WebSocket connection to notify
+   */
+  private _notifyStreamResuming;
+  /**
+   * Send stream chunks to a connection after receiving ACK.
+   * @param connection - The WebSocket connection
+   * @param streamId - The stream to replay
+   * @param requestId - The original request ID
+   */
+  private _sendStreamChunks;
+  /**
+   * Buffer a stream chunk for batch write to SQLite.
+   * @param streamId - The stream this chunk belongs to
+   * @param body - The serialized chunk body
+   */
+  private _storeStreamChunk;
+  /**
+   * Flush buffered chunks to SQLite in a single batch.
+   * Uses a lock to prevent concurrent flush operations.
+   */
+  private _flushChunkBuffer;
+  /**
+   * Start tracking a new stream for resumable streaming.
+   * Creates metadata entry in SQLite and sets up tracking state.
+   * @param requestId - The unique ID of the chat request
+   * @returns The generated stream ID
+   */
+  private _startStream;
+  /**
+   * Mark a stream as completed and flush any pending chunks.
+   * @param streamId - The stream to mark as completed
+   */
+  private _completeStream;
+  /**
+   * Clean up old completed streams if enough time has passed since last cleanup.
+   * This prevents database growth while avoiding cleanup overhead on every stream completion.
+   */
+  private _maybeCleanupOldStreams;
   private _broadcastChatMessage;
   private _loadMessagesFromDb;
-  onMessage(connection: Connection, message: WSMessage): Promise<void>;
   onRequest(request: Request): Promise<Response>;
   private _tryCatchChat;
   /**
@@ -55,6 +123,11 @@ declare class AIChatAgent<Env = unknown, State = unknown> extends Agent<
     excludeBroadcastIds?: string[]
   ): Promise<void>;
   private _reply;
+  /**
+   * Mark a stream as errored and clean up state.
+   * @param streamId - The stream to mark as errored
+   */
+  private _markStreamError;
   /**
    * For the given message id, look up its associated AbortController
    * If the AbortController does not exist, create and store one in memory
@@ -75,7 +148,7 @@ declare class AIChatAgent<Env = unknown, State = unknown> extends Agent<
    */
   private _destroyAbortControllers;
   /**
-   * When the DO is destroyed, cancel all pending requests
+   * When the DO is destroyed, cancel all pending requests and clean up resources
    */
   destroy(): Promise<void>;
 }

package/dist/ai-chat-agent.js

@@ -1,11 +1,22 @@
-import { t as MessageType } from "./ai-types-B3aQaFv3.js";
-import "./client-BfiZ3HQd.js";
-import "./client-DZhjV_XA.js";
-import "./do-oauth-client-provider-CswoD5Lu.js";
-import { t as Agent } from "./src-C8K3lu37.js";
-import { r as autoTransformMessages } from "./ai-chat-v5-migration-DBHGW4Hv.js";
+import { t as MessageType } from "./ai-types-CrMqkwc_.js";
+import "./client-B3SR12TQ.js";
+import "./client-BZq9qau2.js";
+import "./do-oauth-client-provider-CwqK5SXm.js";
+import { t as Agent } from "./src-D_KKH_4c.js";
+import { r as autoTransformMessages } from "./ai-chat-v5-migration-BSiGZmYU.js";
+import { nanoid } from "nanoid";
 
 //#region src/ai-chat-agent.ts
+/** Number of chunks to buffer before flushing to SQLite */
+const CHUNK_BUFFER_SIZE = 10;
+/** Maximum buffer size to prevent memory issues on rapid reconnections */
+const CHUNK_BUFFER_MAX_SIZE = 100;
+/** Maximum age for a "streaming" stream before considering it stale (ms) - 5 minutes */
+const STREAM_STALE_THRESHOLD_MS = 300 * 1e3;
+/** Default cleanup interval for old streams (ms) - every 10 minutes */
+const CLEANUP_INTERVAL_MS = 600 * 1e3;
+/** Default age threshold for cleaning up completed streams (ms) - 24 hours */
+const CLEANUP_AGE_THRESHOLD_MS = 1440 * 60 * 1e3;
 const decoder = new TextDecoder();
 /**
 * Extension of Agent with built-in chat capabilities
@@ -14,13 +25,279 @@ const decoder = new TextDecoder();
 var AIChatAgent = class extends Agent {
 	constructor(ctx, env) {
 		super(ctx, env);
+		this._activeStreamId = null;
+		this._activeRequestId = null;
+		this._streamChunkIndex = 0;
+		this._chunkBuffer = [];
+		this._isFlushingChunks = false;
+		this._lastCleanupTime = 0;
 		this.sql`create table if not exists cf_ai_chat_agent_messages (
       id text primary key,
       message text not null,
       created_at datetime default current_timestamp
     )`;
+		this.sql`create table if not exists cf_ai_chat_stream_chunks (
+      id text primary key,
+      stream_id text not null,
+      body text not null,
+      chunk_index integer not null,
+      created_at integer not null
+    )`;
+		this.sql`create table if not exists cf_ai_chat_stream_metadata (
+      id text primary key,
+      request_id text not null,
+      status text not null,
+      created_at integer not null,
+      completed_at integer
+    )`;
+		this.sql`create index if not exists idx_stream_chunks_stream_id 
+      on cf_ai_chat_stream_chunks(stream_id, chunk_index)`;
 		this.messages = autoTransformMessages(this._loadMessagesFromDb());
 		this._chatMessageAbortControllers = /* @__PURE__ */ new Map();
+		this._restoreActiveStream();
+		const _onConnect = this.onConnect.bind(this);
+		this.onConnect = async (connection, ctx$1) => {
+			if (this._activeStreamId) this._notifyStreamResuming(connection);
+			return _onConnect(connection, ctx$1);
+		};
+		const _onMessage = this.onMessage.bind(this);
+		this.onMessage = async (connection, message) => {
+			if (typeof message === "string") {
+				let data;
+				try {
+					data = JSON.parse(message);
+				} catch (_error) {
+					return _onMessage(connection, message);
+				}
+				if (data.type === MessageType.CF_AGENT_USE_CHAT_REQUEST && data.init.method === "POST") {
+					const { body } = data.init;
+					const { messages } = JSON.parse(body);
+					const transformedMessages = autoTransformMessages(messages);
+					this._broadcastChatMessage({
+						messages: transformedMessages,
+						type: MessageType.CF_AGENT_CHAT_MESSAGES
+					}, [connection.id]);
+					await this.persistMessages(transformedMessages, [connection.id]);
+					this.observability?.emit({
+						displayMessage: "Chat message request",
+						id: data.id,
+						payload: {},
+						timestamp: Date.now(),
+						type: "message:request"
+					}, this.ctx);
+					const chatMessageId = data.id;
+					const abortSignal = this._getAbortSignal(chatMessageId);
+					return this._tryCatchChat(async () => {
+						const response = await this.onChatMessage(async (_finishResult) => {
+							this._removeAbortController(chatMessageId);
+							this.observability?.emit({
+								displayMessage: "Chat message response",
+								id: data.id,
+								payload: {},
+								timestamp: Date.now(),
+								type: "message:response"
+							}, this.ctx);
+						}, abortSignal ? { abortSignal } : void 0);
+						if (response) await this._reply(data.id, response);
+						else {
+							console.warn(`[AIChatAgent] onChatMessage returned no response for chatMessageId: ${chatMessageId}`);
+							this._broadcastChatMessage({
+								body: "No response was generated by the agent.",
+								done: true,
+								id: data.id,
+								type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+							}, [connection.id]);
+						}
+					});
+				}
+				if (data.type === MessageType.CF_AGENT_CHAT_CLEAR) {
+					this._destroyAbortControllers();
+					this.sql`delete from cf_ai_chat_agent_messages`;
+					this.sql`delete from cf_ai_chat_stream_chunks`;
+					this.sql`delete from cf_ai_chat_stream_metadata`;
+					this._activeStreamId = null;
+					this._activeRequestId = null;
+					this._streamChunkIndex = 0;
+					this.messages = [];
+					this._broadcastChatMessage({ type: MessageType.CF_AGENT_CHAT_CLEAR }, [connection.id]);
+					return;
+				}
+				if (data.type === MessageType.CF_AGENT_CHAT_MESSAGES) {
+					const transformedMessages = autoTransformMessages(data.messages);
+					await this.persistMessages(transformedMessages, [connection.id]);
+					return;
+				}
+				if (data.type === MessageType.CF_AGENT_CHAT_REQUEST_CANCEL) {
+					this._cancelChatRequest(data.id);
+					return;
+				}
+				if (data.type === MessageType.CF_AGENT_STREAM_RESUME_ACK) {
+					if (this._activeStreamId && this._activeRequestId && this._activeRequestId === data.id) this._sendStreamChunks(connection, this._activeStreamId, this._activeRequestId);
+					return;
+				}
+			}
+			return _onMessage(connection, message);
+		};
+	}
+	/**
+	* Restore active stream state if the agent was restarted during streaming.
+	* Called during construction to recover any interrupted streams.
+	* Validates stream freshness to avoid sending stale resume notifications.
+	*/
+	_restoreActiveStream() {
+		const activeStreams = this.sql`
+      select * from cf_ai_chat_stream_metadata 
+      where status = 'streaming' 
+      order by created_at desc 
+      limit 1
+    `;
+		if (activeStreams && activeStreams.length > 0) {
+			const stream = activeStreams[0];
+			const streamAge = Date.now() - stream.created_at;
+			if (streamAge > STREAM_STALE_THRESHOLD_MS) {
+				this.sql`delete from cf_ai_chat_stream_chunks where stream_id = ${stream.id}`;
+				this.sql`delete from cf_ai_chat_stream_metadata where id = ${stream.id}`;
+				console.warn(`[AIChatAgent] Deleted stale stream ${stream.id} (age: ${Math.round(streamAge / 1e3)}s)`);
+				return;
+			}
+			this._activeStreamId = stream.id;
+			this._activeRequestId = stream.request_id;
+			const lastChunk = this.sql`
+        select max(chunk_index) as max_index 
+        from cf_ai_chat_stream_chunks 
+        where stream_id = ${this._activeStreamId}
+      `;
+			this._streamChunkIndex = lastChunk && lastChunk[0]?.max_index != null ? lastChunk[0].max_index + 1 : 0;
+		}
+	}
+	/**
+	* Notify a connection about an active stream that can be resumed.
+	* The client should respond with CF_AGENT_STREAM_RESUME_ACK to receive chunks.
+	* Uses in-memory state for request ID - no extra DB lookup needed.
+	* @param connection - The WebSocket connection to notify
+	*/
+	_notifyStreamResuming(connection) {
+		if (!this._activeStreamId || !this._activeRequestId) return;
+		connection.send(JSON.stringify({
+			type: MessageType.CF_AGENT_STREAM_RESUMING,
+			id: this._activeRequestId
+		}));
+	}
+	/**
+	* Send stream chunks to a connection after receiving ACK.
+	* @param connection - The WebSocket connection
+	* @param streamId - The stream to replay
+	* @param requestId - The original request ID
+	*/
+	_sendStreamChunks(connection, streamId, requestId) {
+		this._flushChunkBuffer();
+		const chunks = this.sql`
+      select * from cf_ai_chat_stream_chunks 
+      where stream_id = ${streamId} 
+      order by chunk_index asc
+    `;
+		for (const chunk of chunks || []) connection.send(JSON.stringify({
+			body: chunk.body,
+			done: false,
+			id: requestId,
+			type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+		}));
+		if (this._activeStreamId !== streamId) connection.send(JSON.stringify({
+			body: "",
+			done: true,
+			id: requestId,
+			type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+		}));
+	}
+	/**
+	* Buffer a stream chunk for batch write to SQLite.
+	* @param streamId - The stream this chunk belongs to
+	* @param body - The serialized chunk body
+	*/
+	_storeStreamChunk(streamId, body) {
+		if (this._chunkBuffer.length >= CHUNK_BUFFER_MAX_SIZE) this._flushChunkBuffer();
+		this._chunkBuffer.push({
+			id: nanoid(),
+			streamId,
+			body,
+			index: this._streamChunkIndex
+		});
+		this._streamChunkIndex++;
+		if (this._chunkBuffer.length >= CHUNK_BUFFER_SIZE) this._flushChunkBuffer();
+	}
+	/**
+	* Flush buffered chunks to SQLite in a single batch.
+	* Uses a lock to prevent concurrent flush operations.
+	*/
+	_flushChunkBuffer() {
+		if (this._isFlushingChunks || this._chunkBuffer.length === 0) return;
+		this._isFlushingChunks = true;
+		try {
+			const chunks = this._chunkBuffer;
+			this._chunkBuffer = [];
+			const now = Date.now();
+			for (const chunk of chunks) this.sql`
+          insert into cf_ai_chat_stream_chunks (id, stream_id, body, chunk_index, created_at)
+          values (${chunk.id}, ${chunk.streamId}, ${chunk.body}, ${chunk.index}, ${now})
+        `;
+		} finally {
+			this._isFlushingChunks = false;
+		}
+	}
+	/**
+	* Start tracking a new stream for resumable streaming.
+	* Creates metadata entry in SQLite and sets up tracking state.
+	* @param requestId - The unique ID of the chat request
+	* @returns The generated stream ID
+	*/
+	_startStream(requestId) {
+		this._flushChunkBuffer();
+		const streamId = nanoid();
+		this._activeStreamId = streamId;
+		this._activeRequestId = requestId;
+		this._streamChunkIndex = 0;
+		this.sql`
+      insert into cf_ai_chat_stream_metadata (id, request_id, status, created_at)
+      values (${streamId}, ${requestId}, 'streaming', ${Date.now()})
+    `;
+		return streamId;
+	}
+	/**
+	* Mark a stream as completed and flush any pending chunks.
+	* @param streamId - The stream to mark as completed
+	*/
+	_completeStream(streamId) {
+		this._flushChunkBuffer();
+		this.sql`
+      update cf_ai_chat_stream_metadata 
+      set status = 'completed', completed_at = ${Date.now()} 
+      where id = ${streamId}
+    `;
+		this._activeStreamId = null;
+		this._activeRequestId = null;
+		this._streamChunkIndex = 0;
+		this._maybeCleanupOldStreams();
+	}
+	/**
+	* Clean up old completed streams if enough time has passed since last cleanup.
+	* This prevents database growth while avoiding cleanup overhead on every stream completion.
+	*/
+	_maybeCleanupOldStreams() {
+		const now = Date.now();
+		if (now - this._lastCleanupTime < CLEANUP_INTERVAL_MS) return;
+		this._lastCleanupTime = now;
+		const cutoff = now - CLEANUP_AGE_THRESHOLD_MS;
+		this.sql`
+      delete from cf_ai_chat_stream_chunks 
+      where stream_id in (
+        select id from cf_ai_chat_stream_metadata 
+        where status = 'completed' and completed_at < ${cutoff}
+      )
+    `;
+		this.sql`
+      delete from cf_ai_chat_stream_metadata 
+      where status = 'completed' and completed_at < ${cutoff}
+    `;
 	}
 	_broadcastChatMessage(message, exclude) {
 		this.broadcast(JSON.stringify(message), exclude);
@@ -35,68 +312,8 @@ var AIChatAgent = class extends Agent {
 			}
 		}).filter((msg) => msg !== null);
 	}
-	async onMessage(connection, message) {
-		if (typeof message === "string") {
-			let data;
-			try {
-				data = JSON.parse(message);
-			} catch (_error) {
-				return;
-			}
-			if (data.type === MessageType.CF_AGENT_USE_CHAT_REQUEST && data.init.method === "POST") {
-				const { body } = data.init;
-				const { messages } = JSON.parse(body);
-				const transformedMessages = autoTransformMessages(messages);
-				this._broadcastChatMessage({
-					messages: transformedMessages,
-					type: MessageType.CF_AGENT_CHAT_MESSAGES
-				}, [connection.id]);
-				await this.persistMessages(transformedMessages, [connection.id]);
-				this.observability?.emit({
-					displayMessage: "Chat message request",
-					id: data.id,
-					payload: {},
-					timestamp: Date.now(),
-					type: "message:request"
-				}, this.ctx);
-				const chatMessageId = data.id;
-				const abortSignal = this._getAbortSignal(chatMessageId);
-				return this._tryCatchChat(async () => {
-					const response = await this.onChatMessage(async (_finishResult) => {
-						this._removeAbortController(chatMessageId);
-						this.observability?.emit({
-							displayMessage: "Chat message response",
-							id: data.id,
-							payload: {},
-							timestamp: Date.now(),
-							type: "message:response"
-						}, this.ctx);
-					}, abortSignal ? { abortSignal } : void 0);
-					if (response) await this._reply(data.id, response);
-					else {
-						console.warn(`[AIChatAgent] onChatMessage returned no response for chatMessageId: ${chatMessageId}`);
-						this._broadcastChatMessage({
-							body: "No response was generated by the agent.",
-							done: true,
-							id: data.id,
-							type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
-						}, [connection.id]);
-					}
-				});
-			}
-			if (data.type === MessageType.CF_AGENT_CHAT_CLEAR) {
-				this._destroyAbortControllers();
-				this.sql`delete from cf_ai_chat_agent_messages`;
-				this.messages = [];
-				this._broadcastChatMessage({ type: MessageType.CF_AGENT_CHAT_CLEAR }, [connection.id]);
-			} else if (data.type === MessageType.CF_AGENT_CHAT_MESSAGES) {
-				const transformedMessages = autoTransformMessages(data.messages);
-				await this.persistMessages(transformedMessages, [connection.id]);
-			} else if (data.type === MessageType.CF_AGENT_CHAT_REQUEST_CANCEL) this._cancelChatRequest(data.id);
-		}
-	}
 	async onRequest(request) {
-		return this._tryCatchChat(() => {
+		return this._tryCatchChat(async () => {
 			if (new URL(request.url).pathname.endsWith("/get-messages")) {
 				const messages = this._loadMessagesFromDb();
 				return Response.json(messages);
@@ -154,6 +371,7 @@ var AIChatAgent = class extends Agent {
 				});
 				return;
 			}
+			const streamId = this._startStream(id);
 			const { getToolName, isToolUIPart, parsePartialJson } = await import("ai");
 			const reader = response.body.getReader();
 			const message = {
@@ -221,10 +439,13 @@ var AIChatAgent = class extends Agent {
 					...metadata
 				} : metadata;
 			}
+			let streamCompleted = false;
 			try {
 				while (true) {
 					const { done, value } = await reader.read();
 					if (done) {
+						this._completeStream(streamId);
+						streamCompleted = true;
 						this._broadcastChatMessage({
 							body: "",
 							done: true,
@@ -467,29 +688,54 @@ var AIChatAgent = class extends Agent {
 									});
 									break;
 							}
+							let eventToSend = data;
+							if (data.type === "finish" && "finishReason" in data) {
+								const { finishReason, ...rest } = data;
+								eventToSend = {
+									...rest,
+									type: "finish",
+									messageMetadata: { finishReason }
+								};
+							}
+							const chunkBody = JSON.stringify(eventToSend);
+							this._storeStreamChunk(streamId, chunkBody);
 							this._broadcastChatMessage({
-								body: JSON.stringify(data),
+								body: chunkBody,
 								done: false,
 								id,
 								type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
 							});
-						} catch (_e) {}
+						} catch (_error) {}
 					} else if (chunk.length > 0) {
 						message.parts.push({
 							type: "text",
 							text: chunk
 						});
+						const chunkBody = JSON.stringify({
+							type: "text-delta",
+							delta: chunk
+						});
+						this._storeStreamChunk(streamId, chunkBody);
 						this._broadcastChatMessage({
-							body: JSON.stringify({
-								type: "text-delta",
-								delta: chunk
-							}),
+							body: chunkBody,
 							done: false,
 							id,
 							type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
 						});
 					}
 				}
+			} catch (error) {
+				if (!streamCompleted) {
+					this._markStreamError(streamId);
+					this._broadcastChatMessage({
+						body: error instanceof Error ? error.message : "Stream error",
+						done: true,
+						error: true,
+						id,
+						type: MessageType.CF_AGENT_USE_CHAT_RESPONSE
+					});
+				}
+				throw error;
 			} finally {
 				reader.releaseLock();
 			}
@@ -497,6 +743,21 @@ var AIChatAgent = class extends Agent {
 		});
 	}
 	/**
+	* Mark a stream as errored and clean up state.
+	* @param streamId - The stream to mark as errored
+	*/
+	_markStreamError(streamId) {
+		this._flushChunkBuffer();
+		this.sql`
+      update cf_ai_chat_stream_metadata 
+      set status = 'error', completed_at = ${Date.now()} 
+      where id = ${streamId}
+    `;
+		this._activeStreamId = null;
+		this._activeRequestId = null;
+		this._streamChunkIndex = 0;
+	}
+	/**
 	* For the given message id, look up its associated AbortController
 	* If the AbortController does not exist, create and store one in memory
 	*
@@ -527,10 +788,15 @@ var AIChatAgent = class extends Agent {
 		this._chatMessageAbortControllers.clear();
 	}
 	/**
-	* When the DO is destroyed, cancel all pending requests
+	* When the DO is destroyed, cancel all pending requests and clean up resources
 	*/
 	async destroy() {
 		this._destroyAbortControllers();
+		this._flushChunkBuffer();
+		this.sql`drop table if exists cf_ai_chat_stream_chunks`;
+		this.sql`drop table if exists cf_ai_chat_stream_metadata`;
+		this._activeStreamId = null;
+		this._activeRequestId = null;
 		await super.destroy();
 	}
 };